package commonFile;

import Class.MandreelWindow.GetItemARR;

import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

import static Class.CommonClassFile.*;
import static Class.DevNumber.*;
import static Class.MandreelWindow.mandreelWindow;
import static commonFile.SwriteIndex.swriteIndex;
import static commonFile.TlsfPtr.tlsfPtr1;

public class CommonFile {
    public static boolean debug = false;
    public static void deBugLog(String msg) {
        if (debug) {
            System.out.println(msg);
        }
    }
    public static ArrayList<CreateFileId> fileIds = new ArrayList<CreateFileId>();
    public static int  currentFileId= numDefine20;
    public static int argTestLocal = mallocInt(numDefine8);
    public static int llvmDoubleAddr = mallocInt(numDefine8);
    public static int llvmErrno = mallocInt(numDefine4);
    public static int zgvzn11btMatrix3x311getIdentityEvE14identityMatrix = mallocInt(numDefine8);
    public static int zgvzn11btTransform11getIdentityEvE17identityTransform = mallocInt(numDefine8);
    public static int landscape02Vtx = mallocInt(numDefine23760);
    public static int ztin16btCollisionWorld17RayResultCallbackE = mallocInt(numDefine8);
    public static int ztsn16btCollisionWorld17RayResultCallbackE = mallocInt(numDefine40);
    public static int ztvn16btCollisionWorld24ClosestRayResultCallbackE = mallocInt(numDefine24);
    public static int ztin16btCollisionWorld24ClosestRayResultCallbackE = mallocInt(numDefine12);
    public static int ztsn16btCollisionWorld24ClosestRayResultCallbackE = mallocInt(numDefine47);
    public static int zti13btMotionState = mallocInt(numDefine8);
    public static int zts13btMotionState = mallocInt(numDefine16);
    public static int ztv20btDefaultMotionState = mallocInt(numDefine24);
    public static int zti20btDefaultMotionState = mallocInt(numDefine12);
    public static int zts20btDefaultMotionState = mallocInt(numDefine23);
    public static int zti17btTypedConstraint = mallocInt(numDefine24);
    public static int zts17btTypedConstraint = mallocInt(numDefine20);
    public static int zti13btTypedObject = mallocInt(numDefine8);
    public static int zts13btTypedObject = mallocInt(numDefine16);
    public static int ztv7RagDoll = mallocInt(numDefine16);
    public static int zti7RagDoll = mallocInt(numDefine8);
    public static int zts7RagDoll = mallocInt(numDefine9);
    public static int ztv13BenchmarkDemo = mallocInt(numDefine36);
    public static int zti13BenchmarkDemo = mallocInt(numDefine12);
    public static int zts13BenchmarkDemo = mallocInt(numDefine16);
    public static int zti15DemoApplication = mallocInt(numDefine8);
    public static int zts15DemoApplication = mallocInt(numDefine18);
    public static int zl10raycastBar = mallocInt(numDefine40048);
    public static int twoEStr3 = mallocInt(numDefine48);
    public static int twoEStr4 = mallocInt(numDefine69);
    public static int twoEStr5 = mallocInt(numDefine61);
    public static int twoEStr6 = mallocInt(numDefine50);
    public static int twoEStr7 = mallocInt(numDefine27);
    public static int zl7TaruVtx = mallocInt(numDefine516);
    public static int landscapeVtx = mallocInt(numDefine32);
    public static int landscape01Vtx = mallocInt(numDefine24576);
    public static int landscape03Vtx = mallocInt(numDefine24576);
    public static int landscape04Vtx = mallocInt(numDefine25344);
    public static int landscape05Vtx = mallocInt(numDefine26928);
    public static int landscape06Vtx = mallocInt(numDefine27720);
    public static int landscape07Vtx = mallocInt(numDefine26880);
    public static int landscape08Vtx = mallocInt(numDefine26136);
    public static int landscapeVtxCount = mallocInt(numDefine32);
    public static int landscapeIdx = mallocInt(numDefine32);
    public static int landscape01Idx = mallocInt(numDefine23436);
    public static int landscape02Idx = mallocInt(numDefine22620);
    public static int landscape03Idx = mallocInt(numDefine23436);
    public static int landscape04Idx = mallocInt(numDefine24192);
    public static int landscape05Idx = mallocInt(numDefine25740);
    public static int landscape06Idx = mallocInt(numDefine26520);
    public static int landscape07Idx = mallocInt(numDefine25704);
    public static int landscape08Idx = mallocInt(numDefine24960);
    public static int landscapeIdxCount = mallocInt(numDefine32);
    public static int zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E02E02E0 = mallocInt(numDefine4);
    public static int zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E12E02E1 = mallocInt(numDefine4);
    public static int zzn11btMatrix3x311getIdentityEvE14identityMatrix2E02E22E02E2 = mallocInt(numDefine4);
    public static int zzn11btTransform11getIdentityEvE17identityTransform = mallocInt(numDefine64);
    public static int ztv14BenchmarkDemo4 = mallocInt(numDefine36);
    public static int zti14BenchmarkDemo4 = mallocInt(numDefine12);
    public static int zts14BenchmarkDemo4 = mallocInt(numDefine17);
    public static int zl14benchmarkDemo4 = mallocInt(numDefine80);
    public static int zti21btBroadphaseInterface = mallocInt(numDefine8);
    public static int zts21btBroadphaseInterface = mallocInt(numDefine24);
    public static int zti25btOverlappingPairCallback = mallocInt(numDefine8);
    public static int zts25btOverlappingPairCallback = mallocInt(numDefine28);
    public static int zti22btOverlappingPairCache = mallocInt(numDefine12);
    public static int zts22btOverlappingPairCache = mallocInt(numDefine25);
    public static int ztv15btNullPairCache = mallocInt(numDefine76);
    public static int zti15btNullPairCache = mallocInt(numDefine12);
    public static int zts15btNullPairCache = mallocInt(numDefine18);
    public static int twoEStr11 = mallocInt(numDefine36);
    public static int twoEStr112 = mallocInt(numDefine67);
    public static int twoEStr213 = mallocInt(numDefine18);
    public static int twoEStr314 = mallocInt(numDefine18);
    public static int ztv20btAxisSweep3InternalItE = mallocInt(numDefine64);
    public static int zti20btAxisSweep3InternalItE = mallocInt(numDefine12);
    public static int zts20btAxisSweep3InternalItE = mallocInt(numDefine26);
    public static int ztv12btAxisSweep3 = mallocInt(numDefine64);
    public static int zti12btAxisSweep3 = mallocInt(numDefine12);
    public static int zts12btAxisSweep3 = mallocInt(numDefine15);
    public static int ztv20btCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti20btCollisionAlgorithm = mallocInt(numDefine8);
    public static int zts20btCollisionAlgorithm = mallocInt(numDefine23);
    public static int ztin6btDbvt8ICollideE = mallocInt(numDefine8);
    public static int ztsn6btDbvt8ICollideE = mallocInt(numDefine19);
    public static int twoEStr1118 = mallocInt(numDefine63);
    public static int twoEStr22 = mallocInt(numDefine16);
    public static int ztv18btDbvtTreeCollider = mallocInt(numDefine36);
    public static int zti18btDbvtTreeCollider = mallocInt(numDefine12);
    public static int zts18btDbvtTreeCollider = mallocInt(numDefine21);
    public static int ztv19BroadphaseRayTester = mallocInt(numDefine36);
    public static int zti19BroadphaseRayTester = mallocInt(numDefine12);
    public static int zts19BroadphaseRayTester = mallocInt(numDefine22);
    public static int ztv20BroadphaseAabbTester = mallocInt(numDefine36);
    public static int zti20BroadphaseAabbTester = mallocInt(numDefine12);
    public static int zts20BroadphaseAabbTester = mallocInt(numDefine23);
    public static int twoEStr18 = mallocInt(numDefine73);
    public static int ztv16btDbvtBroadphase = mallocInt(numDefine64);
    public static int zti16btDbvtBroadphase = mallocInt(numDefine12);
    public static int zts16btDbvtBroadphase = mallocInt(numDefine19);
    public static int ztv12btDispatcher = mallocInt(numDefine64);
    public static int zti12btDispatcher = mallocInt(numDefine8);
    public static int zts12btDispatcher = mallocInt(numDefine15);
    public static int zti21btNodeOverlapCallback = mallocInt(numDefine8);
    public static int zts21btNodeOverlapCallback = mallocInt(numDefine24);
    public static int twoEStr10 = mallocInt(numDefine2);
    public static int twoEStr212 = mallocInt(numDefine18);
    public static int twoEStr313 = mallocInt(numDefine69);
    public static int twoEStr414 = mallocInt(numDefine36);
    public static int twoEStr515 = mallocInt(numDefine36);
    public static int twoEStr616 = mallocInt(numDefine36);
    public static int twoEStr717 = mallocInt(numDefine36);
    public static int twoEStr820 = mallocInt(numDefine36);
    public static int twoEStr9 = mallocInt(numDefine36);
    public static int gOverlappingPairs = mallocInt(numDefine4);
    public static int zti17btOverlapCallback = mallocInt(numDefine8);
    public static int zts17btOverlapCallback = mallocInt(numDefine20);
    public static int ztvzn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback = mallocInt(numDefine20);
    public static int ztizn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback = mallocInt(numDefine12);
    public static int ztszn28btHashedOverlappingPairCache19cleanProxyFromPairsEP17btBroadphaseProxyP12btDispatcherE17CleanPairCallback = mallocInt(numDefine110);
    public static int ztvzn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback =
            mallocInt(numDefine20);
    public static int ztizn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback =
            mallocInt(numDefine12);
    public static int ztszn28btHashedOverlappingPairCache37removeOverlappingPairsContainingProxyEP17btBroadphaseProxyP12btDispatcherE18RemovePairCallback =
            mallocInt(numDefine129);
    public static int gRemovePairs = mallocInt(numDefine4);
    public static int ztv28btHashedOverlappingPairCache = mallocInt(numDefine76);
    public static int zti28btHashedOverlappingPairCache = mallocInt(numDefine12);
    public static int zts28btHashedOverlappingPairCache = mallocInt(numDefine31);
    public static int twoEStr121 = mallocInt(numDefine79);
    public static int gAddedPairs = mallocInt(numDefine4);
    public static int twoEStr222 = mallocInt(numDefine38);
    public static int twoEStr323 = mallocInt(numDefine77);
    public static int twoEStr424 = mallocInt(numDefine38);
    public static int twoEStr525 = mallocInt(numDefine38);
    public static int twoEStr626 = mallocInt(numDefine42);
    public static int twoEStr727 = mallocInt(numDefine22);
    public static int gFindPairs = mallocInt(numDefine4);
    public static int twoEStr32 = mallocInt(numDefine23);
    public static int twoEStr133 = mallocInt(numDefine23);
    public static int twoEStr234 = mallocInt(numDefine21);
    public static int twoEStr335 = mallocInt(numDefine24);
    public static int ztv14btQuantizedBvh = mallocInt(numDefine36);
    public static int zti14btQuantizedBvh = mallocInt(numDefine8);
    public static int zts14btQuantizedBvh = mallocInt(numDefine17);
    public static int twoEStr537 = mallocInt(numDefine71);
    public static int twoEStr638 = mallocInt(numDefine48);
    public static int twoEStr739 = mallocInt(numDefine13);
    public static int twoEStr941 = mallocInt(numDefine14);
    public static int twoEStr1143 = mallocInt(numDefine29);
    public static int maxIterations = mallocInt(numDefine4);
    public static int twoEStr1844 = mallocInt(numDefine19);
    public static int twoEStr1921 = mallocInt(numDefine32);
    public static int twoEStr21 = mallocInt(numDefine7);
    public static int twoEStr2246 = mallocInt(numDefine13);
    public static int ztv30btActivatingCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti30btActivatingCollisionAlgorithm = mallocInt(numDefine12);
    public static int zts30btActivatingCollisionAlgorithm = mallocInt(numDefine33);
    public static int twoEStr59 = mallocInt(numDefine14);
    public static int twoEStr160 = mallocInt(numDefine69);
    public static int ztv26btBoxBoxCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti26btBoxBoxCollisionAlgorithm = mallocInt(numDefine12);
    public static int zts26btBoxBoxCollisionAlgorithm = mallocInt(numDefine29);
    public static int zti36btDiscreteCollisionDetectorInterface = mallocInt(numDefine8);
    public static int zts36btDiscreteCollisionDetectorInterface = mallocInt(numDefine39);
    public static int ztv16btBoxBoxDetector = mallocInt(numDefine20);
    public static int zti16btBoxBoxDetector = mallocInt(numDefine12);
    public static int zts16btBoxBoxDetector = mallocInt(numDefine19);
    public static int twoEStr65 = mallocInt(numDefine12);
    public static int twoEStr166 = mallocInt(numDefine71);
    public static int gNumManifold = mallocInt(numDefine4);
    public static int ztin36btDiscreteCollisionDetectorInterface6ResultE = mallocInt(numDefine8);
    public static int ztsn36btDiscreteCollisionDetectorInterface6ResultE = mallocInt(numDefine48);
    public static int ztv23btCollisionPairCallback = mallocInt(numDefine20);
    public static int zti23btCollisionPairCallback = mallocInt(numDefine12);
    public static int zts23btCollisionPairCallback = mallocInt(numDefine26);
    public static int twoEStr169 = mallocInt(numDefine45);
    public static int twoEStr270 = mallocInt(numDefine26);
    public static int twoEStr371 = mallocInt(numDefine14);
    public static int twoEStr472 = mallocInt(numDefine34);
    public static int twoEStr573 = mallocInt(numDefine76);
    public static int ztv21btCollisionDispatcher = mallocInt(numDefine64);
    public static int zti21btCollisionDispatcher = mallocInt(numDefine12);
    public static int zts21btCollisionDispatcher = mallocInt(numDefine24);
    public static int twoEStr674 = mallocInt(numDefine23);
    public static int twoEStr775 = mallocInt(numDefine6);
    public static int twoEStr876 = mallocInt(numDefine6);
    public static int twoEStr977 = mallocInt(numDefine73);
    public static int ztv17btCollisionObject = mallocInt(numDefine36);
    public static int zti17btCollisionObject = mallocInt(numDefine8);
    public static int zts17btCollisionObject = mallocInt(numDefine20);
    public static int twoEStr78 = mallocInt(numDefine27);
    public static int ztin16btCollisionWorld20ConvexResultCallbackE = mallocInt(numDefine8);
    public static int ztsn16btCollisionWorld20ConvexResultCallbackE = mallocInt(numDefine43);
    public static int zti30btConvexPenetrationDepthSolver = mallocInt(numDefine8);
    public static int zts30btConvexPenetrationDepthSolver = mallocInt(numDefine33);
    public static int ztvn12btConvexCast10CastResultE = mallocInt(numDefine24);
    public static int ztin12btConvexCast10CastResultE = mallocInt(numDefine8);
    public static int ztsn12btConvexCast10CastResultE = mallocInt(numDefine29);
    public static int ztvzn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 =
            mallocInt(numDefine24);
    public static int ztizn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 =
            mallocInt(numDefine12);
    public static int ztszn16btCollisionWorld13rayTestSingleERK11btTransformS2P17btCollisionObjectPK16btCollisionShapeS2RNS17RayResultCallbackEE15LocalInfoAdder2 =
            mallocInt(numDefine140);
    public static int ztvzn16CollsionQuerySingObjectPK = mallocInt(numDefine24);
    public static int ztizn16btCollisionWorldCollisionShape = mallocInt(numDefine12);
    public static int ztszn16btConvexResultLocalInfoAdder = mallocInt(numDefine164);
    public static int zti24btBroadphaseAabbCallback = mallocInt(numDefine8);
    public static int zts24btBroadphaseAabbCallback = mallocInt(numDefine27);
    public static int zti23btBroadphaseRayCallback = mallocInt(numDefine12);
    public static int zts23btBroadphaseRayCallback = mallocInt(numDefine26);
    public static int ztv17DebugDrawcallback = mallocInt(numDefine44);
    public static int zti17DebugDrawcallback = mallocInt(numDefine32);
    public static int zts17DebugDrawcallback = mallocInt(numDefine20);
    public static int zti18btTriangleCallback = mallocInt(numDefine8);
    public static int zts18btTriangleCallback = mallocInt(numDefine21);
    public static int zti31btInternalTriangleIndexCallback = mallocInt(numDefine8);
    public static int zts31btInternalTriangleIndexCallback = mallocInt(numDefine34);
    public static int ztv16btCollisionWorld = mallocInt(numDefine56);
    public static int zti16btCollisionWorld = mallocInt(numDefine8);
    public static int zts16btCollisionWorld = mallocInt(numDefine19);
    public static int zti16btManifoldResult = mallocInt(numDefine12);
    public static int zts16btManifoldResult = mallocInt(numDefine19);
    public static int ztv21btSingleSweepCallback = mallocInt(numDefine20);
    public static int zti21btSingleSweepCallback = mallocInt(numDefine12);
    public static int zts21btSingleSweepCallback = mallocInt(numDefine24);
    public static int ztv19btSingleRayCallback = mallocInt(numDefine20);
    public static int zti19btSingleRayCallback = mallocInt(numDefine12);
    public static int zts19btSingleRayCallback = mallocInt(numDefine22);
    public static int twoEStr382 = mallocInt(numDefine23);
    public static int twoEStr483 = mallocInt(numDefine76);
    public static int twoEStr584 = mallocInt(numDefine19);
    public static int twoEStr685 = mallocInt(numDefine42);
    public static int twoEStr786 = mallocInt(numDefine16);
    public static int twoEStr887 = mallocInt(numDefine71);
    public static int twoEStr988 = mallocInt(numDefine82);
    public static int ztvzn16CollsionQuerySingConvex = mallocInt(numDefine24);
    public static int ztizn16btCollisionTransformConvexcastCallback0 = mallocInt(numDefine12);
    public static int ztszn16btCollisionQuerySingleShapeRK11 = mallocInt(numDefine184);
    public static int zti28btTriangleConvexcastCallback = mallocInt(numDefine12);
    public static int zts28btTriangleConvexcastCallback = mallocInt(numDefine31);
    public static int ztvzn16CollsionQuery = mallocInt(numDefine24);
    public static int ztizn16btCollisionWorld17objectQuerySing = mallocInt(numDefine12);
    public static int ztszn16btCollisionWorld17object = mallocInt(numDefine182);
    public static int ztvzn16CollsionTestCallback0 = mallocInt(numDefine24);
    public static int ztizn16btCollisionWorld13rayObjectPK16bt = mallocInt(numDefine12);
    public static int ztszn16btCollisionObjectPK = mallocInt(numDefine156);
    public static int zti25btTriangleRaycastCallback = mallocInt(numDefine12);
    public static int zts25btTriangleRaycastCallback = mallocInt(numDefine28);
    public static int ztvzn16CollsionTestERK = mallocInt(numDefine24);
    public static int ztizn16btCollisionWorld13rayTestSingle = mallocInt(numDefine12);
    public static int ztszn16btCollisionWorld = mallocInt(numDefine154);
    public static int twoEStr1089 = mallocInt(numDefine16);
    public static int twoEStr1190 = mallocInt(numDefine34);
    public static int twoEStr1291 = mallocInt(numDefine26);
    public static int twoEStr1392 = mallocInt(numDefine26);
    public static int twoEStr1493 = mallocInt(numDefine20);
    public static int zzn16btCollisionWorld16updateSingleAabbEP17btCollisionObjectE8reportMe2EB = mallocInt(1);
    public static int twoEStr1594 = mallocInt(numDefine49);
    public static int twoEStr1695 = mallocInt(numDefine68);
    public static int twoEStr1796 = mallocInt(numDefine65);
    public static int twoEStr1897 = mallocInt(numDefine9);
    public static int twoEStr1998 = mallocInt(numDefine12);
    public static int ztv22btCompoundLeafCallback = mallocInt(numDefine36);
    public static int zti22btCompoundLeafCallback = mallocInt(numDefine12);
    public static int zts22btCompoundLeafCallback = mallocInt(numDefine25);
    public static int twoEStr99 = mallocInt(numDefine42);
    public static int twoEStr1100 = mallocInt(numDefine83);
    public static int twoEStr2101 = mallocInt(numDefine43);
    public static int twoEStr3102 = mallocInt(numDefine41);
    public static int twoEStr4103 = mallocInt(numDefine43);
    public static int twoEStr5104 = mallocInt(numDefine43);
    public static int twoEStr6105 = mallocInt(numDefine9);
    public static int twoEStr7106 = mallocInt(numDefine41);
    public static int ztv28btCompoundCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti28btCompoundCollisionAlgorithm = mallocInt(numDefine12);
    public static int zts28btCompoundCollisionAlgorithm = mallocInt(numDefine31);
    public static int twoEStr109 = mallocInt(numDefine9);
    public static int ztv24btConvexTriangleCallback = mallocInt(numDefine20);
    public static int zti24btConvexTriangleCallback = mallocInt(numDefine12);
    public static int zts24btConvexTriangleCallback = mallocInt(numDefine27);
    public static int zn33btCollisionObjectS1RK = mallocInt(numDefine20);
    public static int ztizn33btConvexConcave = mallocInt(numDefine12);
    public static int ztszn33btConvex = mallocInt(numDefine158);
    public static int ztv15btTriangleShape = mallocInt(numDefine124);
    public static int zti15btTriangleShape = mallocInt(numDefine12);
    public static int zts15btTriangleShape = mallocInt(numDefine18);
    public static int zti23btPolyhedralConvexShape = mallocInt(numDefine12);
    public static int zts23btPolyhedralConvexShape = mallocInt(numDefine26);
    public static int zti21btConvexInternalShape = mallocInt(numDefine12);
    public static int zts21btConvexInternalShape = mallocInt(numDefine24);
    public static int zti13btConvexShape = mallocInt(numDefine12);
    public static int zts13btConvexShape = mallocInt(numDefine16);
    public static int zti16btCollisionShape = mallocInt(numDefine8);
    public static int zts16btCollisionShape = mallocInt(numDefine19);
    public static int twoEStr1110 = mallocInt(numDefine26);
    public static int twoEStr3112 = mallocInt(numDefine66);
    public static int ztv33btConvexConcaveCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti33btConvexConcaveCollisionAlgorithm = mallocInt(numDefine12);
    public static int zts33btConvexConcaveCollisionAlgorithm = mallocInt(numDefine36);
    public static int zti30btCollisionAlgorithmCreateFunc = mallocInt(numDefine8);
    public static int zts30btCollisionAlgorithmCreateFunc = mallocInt(numDefine33);
    public static int ztvn23btConvexConvexAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin23btConvexConvexAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn23btConvexConvexAlgorithm10CreateFuncE = mallocInt(numDefine40);
    public static int ztv24btPerturbedContactResult = mallocInt(numDefine28);
    public static int zti24btPerturbedContactResult = mallocInt(numDefine12);
    public static int zts24btPerturbedContactResult = mallocInt(numDefine27);
    public static int twoEStr115 = mallocInt(numDefine19);
    public static int twoEStr4119 = mallocInt(numDefine49);
    public static int twoEStr5120 = mallocInt(numDefine78);
    public static int ztv23btConvexConvexAlgorithm = mallocInt(numDefine28);
    public static int zti23btConvexConvexAlgorithm = mallocInt(numDefine12);
    public static int zts23btConvexConvexAlgorithm = mallocInt(numDefine26);
    public static int ztv31btConvexPlaneCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti31btConvexPlaneCollisionAlgorithm = mallocInt(numDefine12);
    public static int zts31btConvexPlaneCollisionAlgorithm = mallocInt(numDefine34);
    public static int ztvn31btConvexPlaneCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin31btConvexPlaneCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn31btConvexPlaneCollisionAlgorithm10CreateFuncE = mallocInt(numDefine48);
    public static int zti24btCollisionConfiguration = mallocInt(numDefine8);
    public static int zts24btCollisionConfiguration = mallocInt(numDefine27);
    public static int ztvn33btConvexConcaveCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin33btConvexConcaveCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn33btConvexConcaveCollisionAlgorithm10CreateFuncE = mallocInt(numDefine50);
    public static int ztvn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine20);
    public static int ztin33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine12);
    public static int ztsn33btConvexConcaveCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine57);
    public static int ztvn28btCompoundCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin28btCompoundCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn28btCompoundCollisionAlgorithm10CreateFuncE = mallocInt(numDefine45);
    public static int ztvn28btCompoundCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine20);
    public static int ztin28btCompoundCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine12);
    public static int ztsn28btCompoundCollisionAlgorithm17SwappedCreateFuncE = mallocInt(numDefine52);
    public static int ztvn16btEmptyAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin16btEmptyAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn16btEmptyAlgorithm10CreateFuncE = mallocInt(numDefine33);
    public static int ztvn32btSphereSphereCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin32btSphereSphereCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn32btSphereSphereCollisionAlgorithm10CreateFuncE = mallocInt(numDefine49);
    public static int ztvn34btSphereTriangleCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin34btSphereTriangleCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn34btSphereTriangleCollisionAlgorithm10CreateFuncE = mallocInt(numDefine51);
    public static int ztvn26btBoxBoxCollisionAlgorithm10CreateFuncE = mallocInt(numDefine20);
    public static int ztin26btBoxBoxCollisionAlgorithm10CreateFuncE = mallocInt(numDefine12);
    public static int ztsn26btBoxBoxCollisionAlgorithm10CreateFuncE = mallocInt(numDefine43);
    public static int twoEStr128 = mallocInt(numDefine12);
    public static int twoEStr1129 = mallocInt(numDefine42);
    public static int ztv31btDefaultCollisionConfiguration = mallocInt(numDefine36);
    public static int zti31btDefaultCollisionConfiguration = mallocInt(numDefine12);
    public static int zts31btDefaultCollisionConfiguration = mallocInt(numDefine34);
    public static int ztv16btEmptyAlgorithm = mallocInt(numDefine28);
    public static int zti16btEmptyAlgorithm = mallocInt(numDefine12);
    public static int zts16btEmptyAlgorithm = mallocInt(numDefine19);
    public static int ztv16btManifoldResult = mallocInt(numDefine28);
    public static int twoEStr2149 = mallocInt(numDefine31);
    public static int twoEStr3150 = mallocInt(numDefine12);
    public static int twoEStr5152 = mallocInt(numDefine71);
    public static int twoEStr155 = mallocInt(numDefine28);
    public static int twoEStr1156 = mallocInt(numDefine73);
    public static int twoEStr2157 = mallocInt(numDefine80);
    public static int twoEStr3158 = mallocInt(numDefine15);
    public static int ztv25btSimulationIslandManager = mallocInt(numDefine24);
    public static int zti25btSimulationIslandManager = mallocInt(numDefine8);
    public static int zts25btSimulationIslandManager = mallocInt(numDefine28);
    public static int ztv32btSphereSphereCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti32btSphereSphereCollisionAlgorithm = mallocInt(numDefine12);
    public static int zts32btSphereSphereCollisionAlgorithm = mallocInt(numDefine35);
    public static int ztv34btSphereTriangleCollisionAlgorithm = mallocInt(numDefine28);
    public static int zti34btSphereTriangleCollisionAlgorithm = mallocInt(numDefine12);
    public static int zts34btSphereTriangleCollisionAlgorithm = mallocInt(numDefine37);
    public static int ztv22SphereTriangleDetector = mallocInt(numDefine20);
    public static int zti22SphereTriangleDetector = mallocInt(numDefine12);
    public static int zts22SphereTriangleDetector = mallocInt(numDefine25);
    public static int twoEStr173 = mallocInt(numDefine4);
    public static int twoEStr2175 = mallocInt(numDefine61);
    public static int ztv10btBoxShape = mallocInt(numDefine124);
    public static int zti10btBoxShape = mallocInt(numDefine12);
    public static int zts10btBoxShape = mallocInt(numDefine13);
    public static int twoEStr181 = mallocInt(numDefine16);
    public static int ztvzn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine20);
    public static int ztizn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine12);
    public static int ztszn22btBvhTriangleMeshShape14performRaycastEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine104);
    public static int ztvzn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback = mallocInt(numDefine20);
    public static int ztizn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback = mallocInt(numDefine12);
    public static int ztszn22btBvhTriangleMeshShape17performConvexcastEP18btTriangleCallbackRK9btVector3S4S4S4E21MyNodeOverlapCallback = mallocInt(numDefine113);
    public static int ztvznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine20);
    public static int ztiznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine12);
    public static int ztsznk22btBvhTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E21MyNodeOverlapCallback = mallocInt(numDefine110);
    public static int twoEStr5186 = mallocInt(numDefine70);
    public static int twoEStr6187 = mallocInt(numDefine49);
    public static int twoEStr7188 = mallocInt(numDefine75);
    public static int twoEStr8189 = mallocInt(numDefine24);
    public static int ztv22btBvhTriangleMeshShape = mallocInt(numDefine88);
    public static int zti22btBvhTriangleMeshShape = mallocInt(numDefine12);
    public static int zts22btBvhTriangleMeshShape = mallocInt(numDefine25);
    public static int zti19btTriangleMeshShape = mallocInt(numDefine12);
    public static int zts19btTriangleMeshShape = mallocInt(numDefine22);
    public static int zti14btConcaveShape = mallocInt(numDefine12);
    public static int zts14btConcaveShape = mallocInt(numDefine17);
    public static int twoEStr194 = mallocInt(numDefine13);
    public static int twoEStr4198 = mallocInt(numDefine72);
    public static int twoEStr6199 = mallocInt(numDefine19);
    public static int ztv14btCapsuleShape = mallocInt(numDefine92);
    public static int zti14btCapsuleShape = mallocInt(numDefine12);
    public static int zts14btCapsuleShape = mallocInt(numDefine17);
    public static int twoEStr200 = mallocInt(numDefine21);
    public static int ztv14btConcaveShape = mallocInt(numDefine72);
    public static int twoEStr219 = mallocInt(numDefine7);
    public static int twoEStr3222 = mallocInt(numDefine70);
    public static int ztv17btConvexHullShape = mallocInt(numDefine120);
    public static int zti17btConvexHullShape = mallocInt(numDefine12);
    public static int zts17btConvexHullShape = mallocInt(numDefine20);
    public static int zti34btPolyhedralConvexAabbCachingShape = mallocInt(numDefine12);
    public static int zts34btPolyhedralConvexAabbCachingShape = mallocInt(numDefine37);
    public static int twoEStr5223 = mallocInt(numDefine19);
    public static int twoEStr6224 = mallocInt(numDefine22);
    public static int twoEStr6232 = mallocInt(numDefine19);
    public static int ztv13btConvexShape = mallocInt(numDefine92);
    public static int twoEStr6249 = mallocInt(numDefine13);
    public static int twoEStr7250 = mallocInt(numDefine66);
    public static int ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback = mallocInt(numDefine20);
    public static int ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback = mallocInt(numDefine12);
    public static int ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E20NodeTriangleCallback = mallocInt(numDefine91);
    public static int ztvzn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback = mallocInt(numDefine20);
    public static int ztizn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback = mallocInt(numDefine12);
    public static int ztszn14btOptimizedBvh5buildEP23btStridingMeshInterfacebRK9btVector3S4E29QuantizedNodeTriangleCallback = mallocInt(numDefine100);
    public static int twoEStr10306 = mallocInt(numDefine67);
    public static int twoEStr18314 = mallocInt(numDefine36);
    public static int twoEStr19315 = mallocInt(numDefine48);
    public static int twoEStr20316 = mallocInt(numDefine17);
    public static int ztv14btOptimizedBvh = mallocInt(numDefine40);
    public static int zti14btOptimizedBvh = mallocInt(numDefine12);
    public static int zts14btOptimizedBvh = mallocInt(numDefine17);
    public static int twoEStr7331 = mallocInt(numDefine74);
    public static int zgvzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions = mallocInt(numDefine8);
    public static int zzn34btPolyhedralConvexAabbCachingShape15recalcLocalAabbEvE11Directions = mallocInt(numDefine96);
    public static int twoEStr342 = mallocInt(numDefine7);
    public static int ztv13btSphereShape = mallocInt(numDefine92);
    public static int zti13btSphereShape = mallocInt(numDefine12);
    public static int zts13btSphereShape = mallocInt(numDefine16);
    public static int twoEStr349 = mallocInt(numDefine15);
    public static int twoEStr1350 = mallocInt(numDefine27);
    public static int twoEStr3352 = mallocInt(numDefine76);
    public static int twoEStr5354 = mallocInt(numDefine20);
    public static int twoEStr6355 = mallocInt(numDefine44);
    public static int twoEStr7356 = mallocInt(numDefine15);
    public static int twoEStr8357 = mallocInt(numDefine28);
    public static int twoEStr9358 = mallocInt(numDefine61);
    public static int ztv23btStridingMeshInterface = mallocInt(numDefine68);
    public static int zti23btStridingMeshInterface = mallocInt(numDefine8);
    public static int zts23btStridingMeshInterface = mallocInt(numDefine26);
    public static int ztv31btInternalTriangleIndexCallback = mallocInt(numDefine20);
    public static int ztv18btTriangleCallback = mallocInt(numDefine20);
    public static int twoEStr367 = mallocInt(numDefine26);
    public static int twoEStr1368 = mallocInt(numDefine79);
    public static int ztv26btTriangleIndexVertexArray = mallocInt(numDefine68);
    public static int zti26btTriangleIndexVertexArray = mallocInt(numDefine12);
    public static int zts26btTriangleIndexVertexArray = mallocInt(numDefine29);
    public static int twoEStr372 = mallocInt(numDefine13);
    public static int ztv21SupportVertexCallback = mallocInt(numDefine20);
    public static int zti21SupportVertexCallback = mallocInt(numDefine12);
    public static int zts21SupportVertexCallback = mallocInt(numDefine24);
    public static int ztvznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback = mallocInt(numDefine20);
    public static int ztiznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback = mallocInt(numDefine12);
    public static int ztsznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback = mallocInt(numDefine102);
    public static int twoEStr3375 = mallocInt(numDefine72);
    public static int ztv19btTriangleMeshShape = mallocInt(numDefine80);
    public static int ztv16btPointCollector = mallocInt(numDefine28);
    public static int zti16btPointCollector = mallocInt(numDefine12);
    public static int zts16btPointCollector = mallocInt(numDefine19);
    public static int ztv27btContinuousConvexCollision = mallocInt(numDefine20);
    public static int zti27btContinuousConvexCollision = mallocInt(numDefine12);
    public static int zts27btContinuousConvexCollision = mallocInt(numDefine30);
    public static int zti12btConvexCast = mallocInt(numDefine8);
    public static int zts12btConvexCast = mallocInt(numDefine15);
    public static int ztv12btConvexCast = mallocInt(numDefine20);
    public static int ztv15btGjkConvexCast = mallocInt(numDefine20);
    public static int zti15btGjkConvexCast = mallocInt(numDefine12);
    public static int zts15btGjkConvexCast = mallocInt(numDefine18);
    public static int zzn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRjE4imd3 = mallocInt(numDefine12);
    public static int zzn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonEE4i2m3 = mallocInt(numDefine12);
    public static int ztv30btGjkEpaPenetrationDepthSolver = mallocInt(numDefine20);
    public static int zti30btGjkEpaPenetrationDepthSolver = mallocInt(numDefine12);
    public static int zts30btGjkEpaPenetrationDepthSolver = mallocInt(numDefine33);
    public static int gNumDeepPenetrationChecks = mallocInt(numDefine4);
    public static int ztv17btGjkPairDetector = mallocInt(numDefine20);
    public static int zti17btGjkPairDetector = mallocInt(numDefine12);
    public static int zts17btGjkPairDetector = mallocInt(numDefine20);
    public static int gNumGjkChecks = mallocInt(numDefine4);
    public static int twoEStr425 = mallocInt(numDefine39);
    public static int twoEStr1426 = mallocInt(numDefine71);
    public static int twoEStr2427 = mallocInt(numDefine18);
    public static int twoEStr3428 = mallocInt(numDefine75);
    public static int gContactBreakingThreshold = mallocInt(numDefine4);
    public static int twoEStr434 = mallocInt(numDefine52);
    public static int twoEStr3437 = mallocInt(numDefine78);
    public static int twoEStr4438 = mallocInt(numDefine50);
    public static int ztv28btTriangleConvexcastCallback = mallocInt(numDefine24);
    public static int ztv22btSubsimplexConvexCast = mallocInt(numDefine20);
    public static int zti22btSubsimplexConvexCast = mallocInt(numDefine12);
    public static int zts22btSubsimplexConvexCast = mallocInt(numDefine25);
    public static int twoEStr457 = mallocInt(numDefine16);
    public static int twoEStr1458 = mallocInt(numDefine80);
    public static int ztvn16btCollisionWorld27ClosestConvexResultCallbackE = mallocInt(numDefine24);
    public static int ztin16btCollisionWorld27ClosestConvexResultCallbackE = mallocInt(numDefine12);
    public static int ztsn16btCollisionWorld27ClosestConvexResultCallbackE = mallocInt(numDefine50);
    public static int twoEStr36 = mallocInt(numDefine51);
    public static int twoEStr239 = mallocInt(numDefine26);
    public static int ztv21btConeTwistConstraint = mallocInt(numDefine52);
    public static int zti21btConeTwistConstraint = mallocInt(numDefine12);
    public static int zts21btConeTwistConstraint = mallocInt(numDefine24);
    public static int twoEStr1340 = mallocInt(numDefine37);
    public static int twoEStr24 = mallocInt(numDefine74);
    public static int twoEStr442 = mallocInt(numDefine37);
    public static int twoEStr543 = mallocInt(numDefine37);
    public static int twoEStr846 = mallocInt(numDefine24);
    public static int twoEStr947 = mallocInt(numDefine66);
    public static int twoEStr1149 = mallocInt(numDefine30);
    public static int twoEStr29 = mallocInt(numDefine27);
    public static int ztv17btHingeConstraint = mallocInt(numDefine52);
    public static int zti17btHingeConstraint = mallocInt(numDefine12);
    public static int zts17btHingeConstraint = mallocInt(numDefine20);
    public static int twoEStr130 = mallocInt(numDefine34);
    public static int twoEStr231 = mallocInt(numDefine70);
    public static int twoEStr332 = mallocInt(numDefine34);
    public static int twoEStr433 = mallocInt(numDefine34);
    public static int gNumSplitImpulseRecoveries = mallocInt(numDefine4);
    public static int zti18btConstraintSolver = mallocInt(numDefine8);
    public static int zts18btConstraintSolver = mallocInt(numDefine21);
    public static int ztv35btSequentialImpulseConstraintSolver = mallocInt(numDefine48);
    public static int zti35btSequentialImpulseConstraintSolver = mallocInt(numDefine12);
    public static int zts35btSequentialImpulseConstraintSolver = mallocInt(numDefine38);
    public static int zgvzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed = mallocInt(numDefine8);
    public static int zzn35btSequentialImpulseConstraintSolver12getFixedBodyEvE7sFixed = mallocInt(numDefine608);
    public static int twoEStr248 = mallocInt(numDefine27);
    public static int twoEStr34955 = mallocInt(numDefine54);
    public static int twoEStr450 = mallocInt(numDefine11);
    public static int twoEStr551 = mallocInt(numDefine7);
    public static int twoEStr652 = mallocInt(numDefine88);
    public static int twoEStr753 = mallocInt(numDefine10);
    public static int twoEStr854 = mallocInt(numDefine34);
    public static int twoEStr955 = mallocInt(numDefine3);
    public static int twoEStr1056 = mallocInt(numDefine29);
    public static int twoEStr1157 = mallocInt(numDefine24);
    public static int twoEStr76 = mallocInt(numDefine22);
    public static int zti23btDiscreteDynamicsWorld = mallocInt(numDefine12);
    public static int zts23btDiscreteDynamicsWorld = mallocInt(numDefine26);
    public static int zti15btDynamicsWorld = mallocInt(numDefine12);
    public static int zts15btDynamicsWorld = mallocInt(numDefine18);
    public static int ztin25btSimulationIslandManager14IslandCallbackE = mallocInt(numDefine8);
    public static int ztsn25btSimulationIslandManager14IslandCallbackE = mallocInt(numDefine46);
    public static int ztv34btClosestNotMeConvexResultCallback = mallocInt(numDefine24);
    public static int zti34btClosestNotMeConvexResultCallback = mallocInt(numDefine12);
    public static int zts34btClosestNotMeConvexResultCallback = mallocInt(numDefine37);
    public static int ztvzn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback = mallocInt(numDefine20);
    public static int ztizn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback = mallocInt(numDefine12);
    public static int ztszn23btDiscreteDynamicsWorld16solveConstraintsER19btContactSolverInfoE27InplaceSolverIslandCallback = mallocInt(numDefine99);
    public static int twoEStr87 = mallocInt(numDefine26);
    public static int twoEStr188 = mallocInt(numDefine27);
    public static int twoEStr289 = mallocInt(numDefine14);
    public static int twoEStr794 = mallocInt(numDefine20);
    public static int twoEStr895 = mallocInt(numDefine20);
    public static int gNumClampedCcdMotions = mallocInt(numDefine4);
    public static int twoEStr996 = mallocInt(numDefine17);
    public static int twoEStr1097 = mallocInt(numDefine22);
    public static int twoEStr1198 = mallocInt(numDefine29);
    public static int twoEStr1299 = mallocInt(numDefine15);
    public static int twoEStr13100 = mallocInt(numDefine5);
    public static int twoEStr1461 = mallocInt(numDefine68);
    public static int twoEStr1562 = mallocInt(numDefine24);
    public static int twoEStr16101 = mallocInt(numDefine15);
    public static int ztv15btDynamicsWorld = mallocInt(numDefine140);
    public static int ztv23btDiscreteDynamicsWorld = mallocInt(numDefine180);
    public static int zl8uniqueId = mallocInt(numDefine4);
    public static int ztv11btRigidBody = mallocInt(numDefine36);
    public static int zti11btRigidBody = mallocInt(numDefine12);
    public static int zts11btRigidBody = mallocInt(numDefine14);
    public static int twoEStr4144 = mallocInt(numDefine21);
    public static int gDisableDeactivation = mallocInt(1);
    public static int gNumAlignedAllocs = mallocInt(numDefine4);
    public static int gNumAlignedFree = mallocInt(numDefine4);
    public static int zn15CProfileManager12FrameCounterE = mallocInt(numDefine4);
    public static int zn15CProfileManager4RootE = mallocInt(numDefine32);
    public static int zl13gProfileClock2E0 = mallocInt(numDefine4);
    public static int zn15CProfileManager11CurrentNodeE = mallocInt(numDefine4);
    public static int twoEStr729 = mallocInt(numDefine5);
    public static int zn4RwL12RwCatlistE2E0 = mallocInt(numDefine4);
    public static int zn4RwL12RwCatlistE2E1 = mallocInt(numDefine4);
    public static int zn4RwL12RwCatlistE2E2 = mallocInt(numDefine4);
    public static int llvm2EEh2ECatch2EAll2EValue = mallocInt(numDefine4);
    public static int ztin4Rw10RwFacetE = mallocInt(numDefine12);
    public static int ztsn4Rw10RwFacetE = mallocInt(numDefine20);
    public static int ztin4Rw17RwSynchronizedE = mallocInt(numDefine8);
    public static int ztsn4Rw17RwSynchronizedE = mallocInt(numDefine27);
    public static int twoEStr4131 = mallocInt(numDefine10);
    public static int twoEStr15132 = mallocInt(numDefine21);
    public static int twoEStr26 = mallocInt(1);
    public static int zn4RwL13RwWhatBufE = mallocInt(numDefine256);
    public static int zn4RwL16RwWhatRefcntE = mallocInt(numDefine4);
    public static int twoEStr3133 = mallocInt(numDefine16);
    public static int twoEStr47 = mallocInt(numDefine25);
    public static int twoEStr5134 = mallocInt(numDefine18);
    public static int zzn4RwL13RwVfmtwhatEPcjiS0E7Fname = mallocInt(numDefine4);
    public static int zzn4RwL13RwVfmtwhatEPcjiS0E6buffer = mallocInt(numDefine11);
    public static int twoEStr7136 = mallocInt(numDefine3);
    public static int zzn4RwL13RwVfmtwhatEPcjiS0E8Catset = mallocInt(numDefine4);
    public static int zzn4RwL13RwVfmtwhatEPcjiS0E4msgs = mallocInt(numDefine32);
    public static int zzn4RwL13RwVfmtwhatEPcjiS0E5Cat = mallocInt(numDefine4);
    public static int zzn4Rw10RwThrowEizE6errors = mallocInt(numDefine100);
    public static int twoEStr8137 = mallocInt(numDefine26);
    public static int twoEStr9138 = mallocInt(numDefine18);
    public static int twoEStr10139 = mallocInt(numDefine29);
    public static int twoEStr11140 = mallocInt(numDefine33);
    public static int twoEStr12141 = mallocInt(numDefine17);
    public static int twoEStr138142 = mallocInt(numDefine20);
    public static int twoEStr14143 = mallocInt(numDefine21);
    public static int twoEStr159144 = mallocInt(numDefine25);
    public static int twoEStr16145 = mallocInt(numDefine51);
    public static int twoEStr17146 = mallocInt(numDefine47);
    public static int twoEStr18147 = mallocInt(numDefine22);
    public static int twoEStr19148 = mallocInt(numDefine44);
    public static int twoEStr20149 = mallocInt(numDefine23);
    public static int twoEStr21150 = mallocInt(numDefine24);
    public static int twoEStr22151 = mallocInt(numDefine39);
    public static int twoEStr23152 = mallocInt(numDefine38);
    public static int twoEStr24153 = mallocInt(numDefine38);
    public static int twoEStr25154 = mallocInt(numDefine29);
    public static int twoEStr2610 = mallocInt(numDefine44);
    public static int twoEStr27 = mallocInt(numDefine30);
    public static int twoEStr28155 = mallocInt(numDefine40);
    public static int twoEStr29156 = mallocInt(numDefine26);
    public static int twoEStr30 = mallocInt(numDefine27);
    public static int twoEStr31 = mallocInt(numDefine30);
    public static int twoEStr32157 = mallocInt(numDefine32);
    public static int twoEStr33 = mallocInt(numDefine11);
    public static int twoEStr134 = mallocInt(numDefine9);
    public static int twoEStr235 = mallocInt(numDefine12);
    public static int twoEStr336 = mallocInt(numDefine11);
    public static int twoEStr437 = mallocInt(numDefine8);
    public static int ztvn4Rw10RwFacetE = mallocInt(numDefine16);
    public static int twoEStr538 = mallocInt(numDefine2);
    public static int zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE12nStdFacets = mallocInt(numDefine4);
    public static int zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE10stdFacets = mallocInt(numDefine4);
    public static int zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE13stdFacetBuf = mallocInt(numDefine1664);
    public static int zzn4Rw10RwFacet9CManageEPS0NS013CFacetTypeEPKcPFS1JS4EE17stdFacetBufsize = mallocInt(numDefine4);
    public static int zzn4Rw10RwFacetD4EvE9destroyed = mallocInt(numDefine24);
    public static int zn4Rw9RwCatsE = mallocInt(numDefine72);
    public static int twoEStr785 = mallocInt(numDefine2);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE6global = mallocInt(numDefine4);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE5ginit = mallocInt(numDefine4);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE9nLocales = mallocInt(numDefine4);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE7locales = mallocInt(numDefine4);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE10localeBuf = mallocInt(numDefine32);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE14localeBufsize = mallocInt(numDefine4);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE7classic = mallocInt(numDefine4);
    public static int zzn4Rw11RwLocale9CManageEPS0PKcE12classicBody = mallocInt(numDefine172);
    public static int zn4RwL22RwClassicOnceInitE2E02EB = mallocInt(1);
    public static int zn4RwL12RwClassicE = mallocInt(numDefine4);
    public static int twoEStr292167 = mallocInt(numDefine4);
    public static int twoEStr10100175 = mallocInt(numDefine29);
    public static int twoEStr12102177 = mallocInt(numDefine33);
    public static int zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE4init2EB = mallocInt(1);
    public static int zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE8catalogs = mallocInt(numDefine4);
    public static int zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11catalogBuf = mallocInt(numDefine64);
    public static int zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE15catalogBufsize = mallocInt(numDefine4);
    public static int zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE10nCatalogs = mallocInt(numDefine4);
    public static int zzn4RwL20RwManageCatDataERiPNS18RwOpenCatDataEE11largestCat = mallocInt(numDefine4);
    public static int twoEStr115180 = mallocInt(numDefine27);
    public static int twoEStr1116181 = mallocInt(numDefine25);
    public static int twoEStr2131 = mallocInt(numDefine2);
    public static int twoEStr4133 = mallocInt(numDefine2);
    public static int zzn4Rw16RwLocaleNameEiPKcRNS14RwPodArrayIcLj256EEEE11localeRoot = mallocInt(numDefine259);
    public static int znss11CNullRefE = mallocInt(numDefine16);
    public static int ztvst8messagesIcE = mallocInt(numDefine28);
    public static int ztist8messagesIcE = mallocInt(numDefine32);
    public static int ztsst8messagesIcE = mallocInt(numDefine15);
    public static int ztist13messagesBase = mallocInt(numDefine8);
    public static int ztsst13messagesBase = mallocInt(numDefine18);
    public static int twoEStr2360 = mallocInt(numDefine31);
    public static int twoEStr3361 = mallocInt(numDefine48);
    public static int twoEStr4362 = mallocInt(numDefine31);
    public static int ztvst9typeInfo = mallocInt(numDefine24);
    public static int ztist9typeInfo = mallocInt(numDefine8);
    public static int ztsst9typeInfo = mallocInt(numDefine13);
    public static int sMaxMemory = mallocInt(numDefine4);
    public static int sCurrentMemory = mallocInt(numDefine4);
    public static int blockNull = mallocInt(numDefine16);
    public static int twoEStr643 = mallocInt(numDefine57);
    public static int twoEStr1648 = mallocInt(numDefine3);
    public static int twoEStr4651 = mallocInt(numDefine4);
    public static int twoEStr5652 = mallocInt(numDefine4);
    public static int myCtype = mallocInt(numDefine1028);
    public static int zl8nextRand = mallocInt(numDefine4);
    public static int twoEStr7654 = mallocInt(numDefine4);
    public static int twoEStr9655 = mallocInt(numDefine4);
    public static int zl8padLine = mallocInt(numDefine64);
    public static int zl10strtokPos = mallocInt(numDefine4);
    public static int zti14CFileInterface = mallocInt(numDefine8);
    public static int zts14CFileInterface = mallocInt(numDefine17);
    public static int ztv11CFileSystem = mallocInt(numDefine44);
    public static int zti11CFileSystem = mallocInt(numDefine12);
    public static int zts11CFileSystem = mallocInt(numDefine14);
    public static int zl13sFileStdout = mallocInt(numDefine4);
    public static int ztv7CFileLS = mallocInt(numDefine44);
    public static int zti7CFileLS = mallocInt(numDefine12);
    public static int zts7CFileLS = mallocInt(numDefine9);
    public static int ztv10CFileCloud = mallocInt(numDefine44);
    public static int zti10CFileCloud = mallocInt(numDefine12);
    public static int zts10CFileCloud = mallocInt(numDefine13);
    public static int zl10sASockets = mallocInt(numDefine62336);
    public static int ztv11CFileStdout = mallocInt(numDefine44);
    public static int zti11CFileStdout = mallocInt(numDefine12);
    public static int zts11CFileStdout = mallocInt(numDefine14);
    public static int twoEStr31677 = mallocInt(numDefine4);
    public static int twoEStr32678 = mallocInt(numDefine4);
    public static int twoEStr33679 = mallocInt(numDefine5);
    public static int twoEStr34680 = mallocInt(numDefine8);
    public static int twoEStr35681 = mallocInt(numDefine53);
    public static int twoEStr37683 = mallocInt(numDefine4);
    public static int twoEStr38684 = mallocInt(numDefine7);
    public static int zn12mandreelB64L9b64CharsE = mallocInt(numDefine65);
    public static int zn12mandreelB64L11b64IndexesE = mallocInt(numDefine256);
    public static int zl25sMandreelInternalWidth = mallocInt(numDefine4);
    public static int zl26sMandreelInternalHeight = mallocInt(numDefine4);
    public static int gMsgcallback = mallocInt(numDefine4);
    public static int zl24gPFirstTextureAsyncInfo = mallocInt(numDefine4);
    public static int zl17gApPackFileNames = mallocInt(numDefine1024);
    public static int zgvz21MandreelGetTickCountE7sFirst = mallocInt(numDefine8);
    public static int zz21MandreelGetTickCountE7sFirst = mallocInt(numDefine8);
    public static int zz29MandreelInternalPreupdateE8sBfirst2EB = mallocInt(1);
    public static int twoEStr779 = mallocInt(numDefine13);
    public static int twoEStr3782 = mallocInt(numDefine13);
    public static int twoEStr4783 = mallocInt(numDefine37);
    public static int twoEStr5784 = mallocInt(numDefine12);
    public static int twoEStr6785 = mallocInt(numDefine17);
    public static int zz24MandreelInternalInitE54s723478567MandreelMandreelInternalSetResolution = mallocInt(numDefine4);
    public static int zz24MandreelInternalInitE56s723478567MandreelIMandreelTextureAsyncIsCompressed = mallocInt(numDefine4);
    public static int zz24MandreelInternalInitE57s723478567MandreelIMandreelTextureAsyncGetPackOffset = mallocInt(numDefine4);
    public static int zz24MandreelInternalInitE29s723478567MandreelResize = mallocInt(numDefine4);
    public static int zz24MandreelInternalInitE48s723478567MandreelImandreelRestoreGlcontext = mallocInt(numDefine4);
    public static int zz24MandreelInternalInitE46s723478567MandreelImandreelViewportResize = mallocInt(numDefine4);
    public static int ztvn10Cxxabiv120SiClassTypeInfoE = mallocInt(numDefine40);
    public static int ztin10Cxxabiv120SiClassTypeInfoE = mallocInt(numDefine12);
    public static int ztsn10Cxxabiv120SiClassTypeInfoE = mallocInt(numDefine37);
    public static int ztin10Cxxabiv117ClassTypeInfoE = mallocInt(numDefine12);
    public static int ztsn10Cxxabiv117ClassTypeInfoE = mallocInt(numDefine34);
    public static int ztvn10Cxxabiv117ClassTypeInfoE = mallocInt(numDefine40);
    public static int ztvn10Cxxabiv121VmiClassTypeInfoE = mallocInt(numDefine40);
    public static int ztin10Cxxabiv121VmiClassTypeInfoE = mallocInt(numDefine12);
    public static int ztsn10Cxxabiv121VmiClassTypeInfoE = mallocInt(numDefine38);
    public static int zl11gAChannels = mallocInt(numDefine9344);
    public static int zl7gBInit2EB = mallocInt(1);
    public static int twoEStr221 = mallocInt(numDefine8);
    public static int twoEStr1222 = mallocInt(numDefine21);
    public static int zl21gPFirstSoundDuration = mallocInt(numDefine4);
    public static int twoEStr3224 = mallocInt(numDefine71);
    public static int twoEStr4225 = mallocInt(numDefine8);
    public static int zl15gIFreeChannels = mallocInt(numDefine4);
    public static int zl15gAFreeChannels = mallocInt(numDefine128);
    public static int zl6gBLog = mallocInt(1);
    public static int twoEStr12233 = mallocInt(numDefine5);
    public static int twoEStr22243 = mallocInt(numDefine21);
    public static int twoEStr24245 = mallocInt(numDefine86);
    public static int twoEStr26247 = mallocInt(numDefine8);
    public static int twoEStr27248 = mallocInt(numDefine4);
    public static int twoEStr28249 = mallocInt(numDefine60);
    public static int twoEStr29250 = mallocInt(numDefine10);
    public static int twoEStr30251 = mallocInt(numDefine3);
    public static int twoEStr31252 = mallocInt(numDefine75);
    public static int twoEStr32253 = mallocInt(numDefine5);
    public static int twoEStr33254 = mallocInt(numDefine4);
    public static int twoEStr34255 = mallocInt(numDefine9);
    public static int twoEStr35256 = mallocInt(numDefine22);
    public static int zzl32MandreelInitTcpSocketLibrayvE47s723478567MandreelMandreelFlashTcpOnError = mallocInt(numDefine4);
    public static int zl13sFifoErrors = mallocInt(numDefine24);
    public static int zn5myGlL9mContextE = mallocInt(numDefine324);
    public static int llvm2EGlobalCtors = mallocInt(numDefine40);
    public static int llvm2EGlobalDtors = mallocInt(numDefine56);
    public static int llvm2EUsed = mallocInt(numDefine300);
    public static int myHeapNewPos = 0;
    public interface ArkTools {
         int timeInUs(int args);
    }


    public static int mandreelTotalMemory = numDefine08864;
    public static int mandreelStackMemory = numDefine48576;
    public static int mandreelHeapMemory = numDefine91752;
    public static ArrayList<Consumer<Integer>> functionTable = new ArrayList<>();
    public static int mandreelPosFunctionTable = 1;
    public static int gStackPointer= mallocInt(mandreelStackMemory);
    public static ArrayList<ArrayUniformLocations> arrayIdsOgl = new ArrayList<ArrayUniformLocations>();

    public  static ImandreelGl imandreelGl = new ImandreelGl();

    public  static Map<String, Integer> mandreelCacheFiles = new HashMap<>();

    public static void  cosf(int sp) {
        double value = heapClassInst.heapFloat[sp >> numDefine2];
        commonVariable.fg0 = Math.cos(value);
    }

    public static void dump(String x) {}


    public static void fillPtrFromString(int ptr, String v)  {
        ptr = ptr;
        for (int j = 0; j < v.length(); j=j+1) {
            int data  = v.charAt(j);
            heapClassInst.heapU8[ptr] = (byte) data;
            ptr =ptr + 1;
        }
        heapClassInst.heapU8[ptr] = 0;
    }

    public static void fmodf(int sp) {
        sp = sp;
        double  value = heapClassInst.heapFloat[sp >> numDefine2];
        sp += numDefine4;
        double  value2= heapClassInst.heapFloat[sp >> numDefine2];
    }

    public static void free(int sp) {
        sp = sp;
        int ptr = heapClassInst.heapU32[sp >> numDefine2];
        sp = numDefine8-1;

        heapClassInst.heap32[sp >> numDefine2] = tlsfPtr1.tlsfPtr;
        heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = ptr;
        mandreelFile7.mandreelFile7.tlsfFree(sp);

    }

    public static void getTimeOfDay(int sp) {
        int ptr = heapClassInst.heap32[sp >> numDefine2];
        int  timeMs = dateNow();
        heapClassInst.heap32[ptr >> numDefine2] = timeMs / numDefine1000;
        heapClassInst.heap32[(ptr >> numDefine2) + 1] = (timeMs % numDefine1000) * numDefine1000;
        commonVariable.rg0 = 0;
    }

    public static int  dateNow() {
        commonVariable.mandreelCurrentTime += numDefine16;
        return commonVariable.mandreelCurrentTime;
    }

    public static void  updateMandreelStats(int time){
        int pause = time - commonVariable.mandreelSampintimeStart;
        commonVariable.mandreelSampintimeStart = time;
        commonVariable.mandreelPauseTimes.add((double) pause);
    }

    public static void jsMandreelFlashTcpUpdate(int sp){}
    public static void mandreelInternalCreateWindow(int sp){}
    public static void  iMandreelRegisterExternalCallback(int sp){}
    public static void  z30MandreelFopenEnableCheckfatb(int sp){}

    public static void  mandreelTextureAsyncSetData(int sp){
        sp = sp;
        int textureId = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;

        ArrayUniformLocations tex = arrayIdsOgl.get(textureId);

        if (commonVariable.mandreelAppPlatform != "canvas") {
            tex = null;
        }
    }


    public static void blockMergeNext(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + 1];
        r2 = (r2 + numDefineNeg4) | 0;
        r2 = r2 & numDefineNeg4;
        r3 = (r0 + numDefine8) | 0;
        r4 = (r2 + numDefine4) | 0;
        r4 = (r3 + r4) | 0;
        r4 = r4 >> numDefine2;
        r5 = heapClassInst.heap32[r4];
        r6 = r5 & 1;
        if (!(r6 == 0)) {
            r6 = heapClassInst.heap32[fp];
            r7 = (r3 + r2) | 0;
            r8 = r5 & numDefineNeg4;
            if (uint(r8) > uint(numDefine255)) {
                r5 = r8 >>> 1;
                r5 = r8 | r5;
                r9 = r5 >>> numDefine2;
                r5 = r5 | r9;
                r9 = r5 >>> numDefine4;
                r5 = r5 | r9;
                r9 = r5 >>> numDefine8;
                r5 = r5 | r9;
                r9 = r5 >>> numDefine16;
                r5 = r5 | r9;
                r9 = r5 ^ -1;
                r10 = numDefine55765;
                r9 = r9 >>> 1;
                r5 = r10 & ~r5;
                r9 = r9 & numDefine55765;
                r5 = (r5 + r9) | 0;
                r9 = r5 >>> numDefine2;
                r5 = r5 & numDefine93459;
                r9 = r9 & numDefine93459;
                r5 = (r5 + r9) | 0;
                r9 = r5 >>> numDefine4;
                r5 = r5 & numDefine45135;
                r9 = r9 & numDefine45135;
                r5 = (r5 + r9) | 0;
                r9 = r5 >>> numDefine8;
                r5 = r5 & numDefine11935;
                r9 = r9 & numDefine11935;
                r5 = (r5 + r9) | 0;
                r9 = r5 & numDefine65535;
                r5 = r5 >>> numDefine16;
                r10 = numDefine26;
                r5 = (r9 + r5) | 0;
                r9 = (r10 - r5) | 0;
                r8 = r8 >>> r9;
                r9 = numDefine24;
                r8 = r8 ^ numDefine32;
                r5 = (r9 - r5) | 0;
            } else {
                r8 = r5 >>> numDefine3;
                r5 = 0;
            }
            r2 = (r2 + r3) | 0;
            r2 = r2 >> numDefine2;
            r9 = r5 << numDefine7;
            r10 = heapClassInst.heap32[r2 + numDefine2];
            r2 = heapClassInst.heap32[r2 + numDefine3];
            r9 = (r6 + r9) | 0;
            r11 = r8 << numDefine2;
            r9 = (r9 + r11) | 0;
            r11 = r10 >>  numDefine2;
            r12 = r2 >> numDefine2;
            heapClassInst.heap32[r11 + numDefine3] = r2;
            r2 = r9 >> numDefine2;
            heapClassInst.heap32[r12 + numDefine2] = r10;
            r2 = heapClassInst.heap32[r2 + numDefine24];
            if (!(r2 != r7)) {
                r2 = (r9 + numDefine96) | 0;
                r2 = r2 >> numDefine2;
                r7 = blockNull;
                heapClassInst.heap32[r2] = r10;
                if (!(r10 != r7)) {
                    r2 = r5 << numDefine2;
                    r2 = (r6 + r2) | 0;
                    r2 = r2 >> numDefine2;
                    r7 = 1;
                    r8 = r7 << r8;
                    r9 = heapClassInst.heap32[r2 + 1];
                    r8 = r9 & ~r8;
                    heapClassInst.heap32[r2 + 1] = r8;
                    if (!(r8 != 0)) {
                        r2 = r6 >> numDefine2;
                        r5 = r7 << r5;
                        r6 = heapClassInst.heap32[r2];
                        r5 = r6 & ~r5;
                        heapClassInst.heap32[r2] = r5;
                    }
                }
            }
            r2 = heapClassInst.heap32[r4];
            r4 = heapClassInst.heap32[r1 + 1];
            r2 = r2 & numDefineNeg4;
            r2 = (r2 + r4) | 0;
            r4 = r2 & numDefineNeg4;
            r3 = (r3 + r4) | 0;
            r2 = (r2 + numDefine4) | 0;
            r3 = r3 >> numDefine2;
            heapClassInst.heap32[r1 + 1] = r2;
            heapClassInst.heap32[r3] = r0;
        }
        commonVariable.rg0 = r0;
        return;
    }

    public static void mandreelAddValidFopenfile(int param){}
    public static void  mandreelFread(int sp){}
    public static void mandreelFclose(int sp){
        sp = sp;
        int fileId = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;

        fileIds.set(fileId, null);
        commonVariable.rg0 = 0;
    }

    public static void mandreelFeof(int sp) {
        sp = sp;
        int fileId = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;

        int offset = fileIds.get(fileId).offset;
        int total = fileIds.get(fileId).count;

        if (offset >= total) {
            commonVariable.rg0 = 1;
        } else {
            commonVariable.rg0 = 0;
        }
    }

    public static void mandreelFtell(int sp) {
        sp = sp;
        int fileId = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int value = fileIds.get(fileId).offset;
        commonVariable.rg0 = value;
    }

    public static void  mandreelFseek(int sp) {
        sp = sp;
        int fileId = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int pos = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int type = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;

        if (type == numDefine2) {
            fileIds.get(fileId).offset = fileIds.get(fileId).count + pos;
        } else if (type == 1) {
            fileIds.get(fileId).offset = fileIds.get(fileId).offset + pos;
        } else if (type == 0) {
            fileIds.get(fileId).offset = pos;
        }

        commonVariable.rg0 = 0;
    }


    public static int mandreelUngetc(int sp) {
        sp = sp;
        int myChar = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int fileId = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int offset = fileIds.get(fileId).offset - 1;
        byte[] byteArray = fileIds.get(fileId).byteArray;
        assert1(byteArray[offset] == myChar);
        fileIds.get(fileId).offset = offset;
        return myChar;
    }

    public static void realloc(int sp) {
        sp = sp;
        int ptr = heapClassInst.heapU32[sp >> numDefine2];
        int size = heapClassInst.heapU32[(sp + numDefine4) >> numDefine2];
        sp -= numDefine12;
        heapClassInst.heap32[sp >> numDefine2] = tlsfPtr1.tlsfPtr;
        heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = ptr;
        heapClassInst.heap32[(sp + numDefine8) >> numDefine2] = size;
        tlsfRealloc(sp);
    }

    public static void tlsfRealloc(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int label = 0;

        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = heapClassInst.heap32[fp + numDefine2];
        if (!(r0 == 0)) {
            if (!(r2 != 0)) {
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r0;
                mandreelFile7.mandreelFile7.tlsfFree(i7);
                r0 = 0;
                commonVariable.rg0 = r0;
                return;
            }
        }
        if (r0 != 0) {
            r3 = r0 >> numDefine2;
            r4 = heapClassInst.heap32[r3 + -1];
            r5 = r4 & numDefineNeg4;
            r6 = (r0 + r5) | 0;
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            r7 = r6 & numDefineNeg4;
            r7 = (r5 + r7) | 0;
            r8 = (r2 + -1) | 0;
            r9 = (r0 + numDefineNeg8) | 0;
            r7 = (r7 + numDefine4) | 0;
            if (uint(r8) < uint(numDefine41823)) {
                r10 = (r2 + numDefine7) | 0;
                r10 = r10 & numDefineNeg8;
                r11 = numDefine12;
                r10 = uint(r10) < uint(r11) ? r11 : r10;
            } else {
                r10 = 0;
            }
            repeat11: do {
                if (uint(r10) > uint(r5)) {
                    r4 = r6 & 1;
                    if (!(r4 == 0)) {
                        if (uint(r10) <= uint(r7)) {
                            heapClassInst.heap32[g0] = r1;
                            heapClassInst.heap32[g0 + 1] = r9;
                            blockMergeNext(i7);
                            r4 = heapClassInst.heap32[r3 + -1];
                            r4 = r4 & numDefineNeg4;
                            r4 = (r0 + r4) | 0;
                            r4 = r4 >> numDefine2;
                            r9 = heapClassInst.heap32[r4];
                            r9 = r9 & numDefineNeg3;
                            heapClassInst.heap32[r4] = r9;
                            r4 = heapClassInst.heap32[r3 + -1];
                            r4 = r4 & numDefineNeg2;
                            heapClassInst.heap32[r3 + -1] = r4;
                            break repeat11;
                        }
                    }
                    if (uint(r8) < uint(numDefine41823)) {
                        r3 = (r2 + numDefine7) | 0;
                        r3 = r3 & numDefineNeg8;
                        r4 = numDefine12;
                        r3 = uint(r3) < uint(r4) ? r4 : r3;
                    } else {
                        r3 = 0;
                    }
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = r3;
                    blockLocateFree(i7);
                    r4 = commonVariable.rg0;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r3;
                    r3 = sCurrentMemory;
                    blockPrepareUsed(i7);
                    r9 = commonVariable.rg0;
                    r4 = r4 >> numDefine2;
                    r3 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r4 + 1];
                    r10 = heapClassInst.heap32[r3];
                    r4 = r4 & numDefineNeg4;
                    r4 = (r10 + r4) | 0;
                    r10 = sMaxMemory;
                    r10 = r10 >> numDefine2;
                    heapClassInst.heap32[r3] = r4;
                    r3 = heapClassInst.heap32[r10];
                    if (!(uint(r4) <= uint(r3))) {
                        heapClassInst.heap32[r10] = r4;
                    }
                    if (r9 == 0) {
                        commonVariable.rg0 = r9;
                        return;
                    } else {
                        r3 = uint(r5) >= uint(r2) ? r2 : r5;
                        heapClassInst.heap32[g0] = r9;
                        heapClassInst.heap32[g0 + 1] = r0;
                        heapClassInst.heap32[g0 + numDefine2] = r3;
                        memcpy(i7);
                        heapClassInst.heap32[g0] = r1;
                        heapClassInst.heap32[g0 + 1] = r0;
                        mandreelFile7.mandreelFile7.tlsfFree(i7);
                        commonVariable.rg0 = r9;
                        return;
                    }
                }
            } while (false);
            r9 = sCurrentMemory;
            r9 = r9 >> numDefine2;
            r2 = heapClassInst.heap32[r9];
            r2 = (r2 - r5) | 0;
            r5 = r4 & numDefineNeg4;
            heapClassInst.heap32[r9] = r2;
            r6 = (r10 + numDefine16) | 0;
            if (uint(r5) >= uint(r6)) {
                r4 = (r0 + r10) | 0;
                r6 = r4 >> numDefine2;
                r7 = numDefineNeg4;
                r8 = heapClassInst.heap32[r6];
                r7 = (r7 - r10) | 0;
                r8 = r8 & numDefine3;
                r5 = (r7 + r5) | 0;
                r5 = r8 | r5;
                heapClassInst.heap32[r6] = r5;
                r5 = heapClassInst.heap32[r3 + -1];
                r5 = r5 & numDefine3;
                r5 = r5 | r10;
                heapClassInst.heap32[r3 + -1] = r5;
                r5 = heapClassInst.heap32[r6];
                r5 = (r5 + numDefineNeg4) | 0;
                r5 = r5 & numDefineNeg4;
                r5 = (r10 + r5) | 0;
                r5 = (r5 + r0) | 0;
                r4 = (r4 + numDefineNeg4) | 0;
                r5 = r5 >> numDefine2;
                heapClassInst.heap32[r5 + 1] = r4;
                r7 = heapClassInst.heap32[r5 + numDefine2];
                r7 = r7 | numDefine2;
                heapClassInst.heap32[r5 + numDefine2] = r7;
                r5 = heapClassInst.heap32[r6];
                r5 = r5 | 1;
                r5 = r5 & numDefineNeg3;
                heapClassInst.heap32[r6] = r5;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r4;
                blockMergeNext(i7);
                r4 = commonVariable.rg0;
                r5 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r5 + 1];
                r6 = r5 & numDefineNeg4;
                if (uint(r6) > uint(numDefine255)) {
                    r5 = r6 >>> 1;
                    r5 = r6 | r5;
                    r7 = r5 >>> numDefine2;
                    r5 = r5 | r7;
                    r7 = r5 >>> numDefine4;
                    r5 = r5 | r7;
                    r7 = r5 >>> numDefine8;
                    r5 = r5 | r7;
                    r7 = r5 >>> numDefine16;
                    r5 = r5 | r7;
                    r7 = r5 ^ -1;
                    r8 = numDefine55765;
                    r7 = r7 >>> 1;
                    r5 = r8 & ~r5;
                    r7 = r7 & numDefine55765;
                    r5 = (r5 + r7) | 0;
                    r7 = r5 >>> numDefine2;
                    r5 = r5 & numDefine93459;
                    r7 = r7 & numDefine93459;
                    r5 = (r5 + r7) | 0;
                    r7 = r5 >>> numDefine4;
                    r5 = r5 & numDefine45135;
                    r7 = r7 & numDefine45135;
                    r5 = (r5 + r7) | 0;
                    r7 = r5 >>> numDefine8;
                    r5 = r5 & numDefine11935;
                    r7 = r7 & numDefine11935;
                    r5 = (r5 + r7) | 0;
                    r7 = r5 & numDefine65535;
                    r5 = r5 >>> numDefine16;
                    r8 = numDefine26;
                    r5 = (r7 + r5) | 0;
                    r7 = (r8 - r5) | 0;
                    r6 = r6 >>> r7;
                    r7 = numDefine24;
                    r6 = r6 ^ numDefine32;
                    r5 = (r7 - r5) | 0;
                } else {
                    r6 = r5 >>> numDefine3;
                    r5 = 0;
                }
                r7 = r5 << numDefine7;
                r7 = (r1 + r7) | 0;
                r8 = r6 << numDefine2;
                r7 = (r7 + r8) | 0;
                r7 = r7 >> numDefine2;
                r8 = heapClassInst.heap32[r7 + numDefine24];
                r10 = r4 >> numDefine2;
                r11 = blockNull;
                heapClassInst.heap32[r10 + numDefine2] = r8;
                r8 = r8 >> numDefine2;
                heapClassInst.heap32[r10 + numDefine3] = r11;
                heapClassInst.heap32[r8 + numDefine3] = r4;
                r8 = 1;
                r10 = r1 >> numDefine2;
                heapClassInst.heap32[r7 + numDefine24] = r4;
                r4 = r5 << numDefine2;
                r5 = r8 << r5;
                r7 = heapClassInst.heap32[r10];
                r4 = (r1 + r4) | 0;
                r1 = r7 | r5;
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r10] = r1;
                r1 = r8 << r6;
                r5 = heapClassInst.heap32[r4 + 1];
                r1 = r5 | r1;
                heapClassInst.heap32[r4 + 1] = r1;
                r4 = heapClassInst.heap32[r3 + -1];
            }
            r1 = r4 & numDefineNeg4;
            r1 = (r2 + r1) | 0;
            r2 = sMaxMemory;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r9] = r1;
            r9 = heapClassInst.heap32[r2];
            if (!(uint(r1) <= uint(r9))) {
                heapClassInst.heap32[r2] = r1;
            }
            commonVariable.rg0 = r0;
            return;
        } else {
            r0 = (r2 + -1) | 0;
            if (uint(r0) < uint(numDefine41823)) {
                r0 = (r2 + numDefine7) | 0;
                r0 = r0 & numDefineNeg8;
                r2 = numDefine12;
                r0 = uint(r0) < uint(r2) ? r2 : r0;
            } else {
                r0 = 0;
            }
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r0;
            blockLocateFree(i7);
            r2 = commonVariable.rg0;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r2;
            heapClassInst.heap32[g0 + numDefine2] = r0;
            r0 = sCurrentMemory;
            blockPrepareUsed(i7);
            r1 = commonVariable.rg0;
            r2 = r2 >> numDefine2;
            r0 = r0 >> numDefine2;
            r2 = heapClassInst.heap32[r2 + 1];
            r3 = heapClassInst.heap32[r0];
            r2 = r2 & numDefineNeg4;
            r2 = (r3 + r2) | 0;
            r3 = sMaxMemory;
            r3 = r3 >> numDefine2;
            heapClassInst.heap32[r0] = r2;
            r0 = heapClassInst.heap32[r3];
            if (!(uint(r2) <= uint(r0))) {
                heapClassInst.heap32[r3] = r2;
            }
            commonVariable.rg0 = r1;
            return;
        }
    }

    public static void mandreelWritels(int sp) {}

    public static void  mandreelOpenls(int sp){
        sp = sp;
        int ptrName = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        String key = getStringFromPtr(ptrName);
        GetItemARR myLocalStorage = mandreelGetlocalstorage();
        String value= myLocalStorage.getItem(key);
        if (value == null) {
            commonVariable.rg0 = -1;
            return;
        }

        String length = myLocalStorage.getItem(key + "Size");

        if (length == null) {
            commonVariable.rg0 = -1;
            return;
        }

        dump("mandreelOpenls " + key + " return " + length);

        commonVariable.rg0 =  Integer.parseInt(length);
    }
    public static void mandreelReadcloud(int sp){}

    public static void mandreelFopen(int sp){
        sp = sp;
        int ptrName = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int ptrFlags = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;

        String name = getStringFromPtr(ptrName);
        String flags = getStringFromPtr(ptrFlags);

        name = name.toLowerCase();

        Integer buffer = mandreelCacheFiles.get(name);

        if (buffer == null) {
            commonVariable.rg0 = 0;
            return;
        }
        fileIds.set(currentFileId, new CreateFileId(new byte[buffer]));

        int oldId = currentFileId;
        currentFileId += 1;
        commonVariable.rg0 = oldId;
    }

    public static void mandreelReadls(int sp){}

    public static void mandreelOpencloud(int param){}

    public static void mandreelWritecloud(int param) {}

    public static void llvmWriteDouble(int addr,int src){
        heapClassInst.heapDouble[llvmDoubleAddr >> numDefine3] = src;

        int val0 = heapClassInst.heap32[llvmDoubleAddr >> numDefine2];
        int val1 = heapClassInst.heap32[(llvmDoubleAddr + numDefine4) >> numDefine2];

        heapClassInst.heap32[addr >> numDefine2] = val0;
        heapClassInst.heap32[(addr + numDefine4) >> numDefine2] = val1;
    }

    public static long uint(long value){
        if (value >= 0) {
            return value;
        }
        return numDefine67296 + value;
    }

    public static void tlsfCreate(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int  g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r0 = (r0 + numDefineNeg3048) | 0;
        r1 = r0 & numDefineNeg8;
        r2 = (int) ((r1 + numDefineNeg12) | 0);
        if (uint(r2) < uint((int) numDefine41813)) {
            r2 = heapClassInst.heap32[fp];
            r3 = blockNull;
            r4 = r3 >> numDefine2;
            heapClassInst.heap32[r4 + numDefine2] = r3;
            r5 = -1;
            r6 = r2 >> numDefine2;
            heapClassInst.heap32[r4 + numDefine3] = r3;
            heapClassInst.heap32[r6] = 0;
            repeat3: while (true) {
                r4 = r5 << numDefine2;
                r7 = r5 << numDefine7;
                r4 = (r2 - r4) | 0;
                r7 = (r2 - r7) | 0;
                r4 = r4 >> numDefine2;
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r4] = 0;
                heapClassInst.heap32[r7 + numDefineNeg8] = r3;
                heapClassInst.heap32[r7 + numDefineNeg7] = r3;
                heapClassInst.heap32[r7 + numDefineNeg6] = r3;
                heapClassInst.heap32[r7 + numDefineNeg5] = r3;
                heapClassInst.heap32[r7 + numDefineNeg4] = r3;
                heapClassInst.heap32[r7 + numDefineNeg3] = r3;
                heapClassInst.heap32[r7 + numDefineNeg2] = r3;
                heapClassInst.heap32[r7 + -1] = r3;
                heapClassInst.heap32[r7] = r3;
                heapClassInst.heap32[r7 + 1] = r3;
                heapClassInst.heap32[r7 + numDefine2] = r3;
                heapClassInst.heap32[r7 + numDefine3] = r3;
                heapClassInst.heap32[r7 + numDefine4] = r3;
                heapClassInst.heap32[r7 + numDefine5] = r3;
                heapClassInst.heap32[r7 + numDefine6] = r3;
                heapClassInst.heap32[r7 + numDefine7] = r3;
                heapClassInst.heap32[r7 + numDefine8] = r3;
                heapClassInst.heap32[r7 + numDefine9] = r3;
                heapClassInst.heap32[r7 + numDefine10] = r3;
                heapClassInst.heap32[r7 + numDefine11] = r3;
                heapClassInst.heap32[r7 + numDefine12] = r3;
                heapClassInst.heap32[r7 + numDefine13] = r3;
                heapClassInst.heap32[r7 + numDefine14] = r3;
                heapClassInst.heap32[r7 + numDefine15] = r3;
                heapClassInst.heap32[r7 + numDefine16] = r3;
                heapClassInst.heap32[r7 + numDefine17] = r3;
                heapClassInst.heap32[r7 + numDefine18] = r3;
                heapClassInst.heap32[r7 + numDefine19] = r3;
                heapClassInst.heap32[r7 + numDefine20] = r3;
                heapClassInst.heap32[r7 + numDefine21] = r3;
                r5 = (r5 + -1);
                heapClassInst.heap32[r7 + numDefine22] = r3;
                heapClassInst.heap32[r7 + numDefine23] = r3;
                if (!(r5 != numDefineNeg24)) {
                    break repeat3;
                }
            }
            r4 = r0 | 1;
            r5 = (r2 + numDefine3036) | 0;
            r4 = r4 & numDefineNeg7;
            heapClassInst.heap32[r6 + numDefine760] = r4;
            if (uint((int) r1) > uint(numDefine255)) {
                r0 = r1 >>> 1;
                r0 = r1 | r0;
                r4 = r0 >>> numDefine2;
                r0 = r0 | r4;
                r4 = r0 >>> numDefine4;
                r0 = r0 | r4;
                r4 = r0 >>> numDefine8;
                r0 = r0 | r4;
                r4 = r0 >>> numDefine16;
                r0 = r0 | r4;
                r4 = r0 ^ -1;
                r7 = numDefine55765;
                r4 = r4 >>> 1;
                r0 = r7 & ~r0;
                r4 = r4 & numDefine55765;
                r0 = (r0 + r4) | 0;
                r4 = r0 >>> numDefine2;
                r0 = r0 & numDefine93459;
                r4 = r4 & numDefine93459;
                r0 = (r0 + r4) | 0;
                r4 = r0 >>> numDefine4;
                r0 = r0 & numDefine45135;
                r4 = r4 & numDefine45135;
                r0 = (r0 + r4) | 0;
                r4 = r0 >>> numDefine8;
                r0 = r0 & numDefine11935;
                r4 = r4 & numDefine11935;
                r0 = (r0 + r4) | 0;
                r4 = r0 & numDefine65535;
                r0 = r0 >>> numDefine16;
                r7 = numDefine26;
                r0 = (r4 + r0) | 0;
                r4 = (r7 - r0) | 0;
                r1 = r1 >>> r4;
                r4 = numDefine24;
                r1 = r1 ^ numDefine32;
                r0 = (r4 - r0) | 0;
            } else {
                r1 = r0 >>> numDefine3;
                r0 = 0;
            }
            r4 = r0 << numDefine7;
            r4 = (r2 + r4) | 0;
            r7 = r1 << numDefine2;
            r4 = (r4 + r7) | 0;
            r4 = r4 >> numDefine2;
            r7 = heapClassInst.heap32[r4 + numDefine24];
            heapClassInst.heap32[r6 + numDefine761] = r7;
            r7 = r7 >> numDefine2;
            heapClassInst.heap32[r6 + numDefine762] = r3;
            heapClassInst.heap32[r7 + numDefine3] = r5;
            r3 = 1;
            heapClassInst.heap32[r4 + numDefine24] = r5;
            r4 = r0 << numDefine2;
            r0 = r3 << r0;
            r7 = heapClassInst.heap32[r6];
            r4 = (r2 + r4) | 0;
            r0 = r7 | r0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r6] = r0;
            r0 = r3 << r1;
            r1 = heapClassInst.heap32[r4 + 1];
            r0 = r1 | r0;
            heapClassInst.heap32[r4 + 1] = r0;
            r0 = heapClassInst.heap32[r6 + numDefine760];
            r0 = (r0 + numDefine3040) | 0;
            r0 = r0 & numDefineNeg4;
            r0 = (r2 + r0) | 0;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0] = r5;
            heapClassInst.heap32[r0 + 1] = numDefine2;
            commonVariable.rg0 = r2;
            return;
        } else {
            r0 = twoEStr643;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = numDefine3060;
            heapClassInst.heap32[g0 + numDefine2] = (int) numDefine44872;
            printf(i7);
            r0 = 0;
            commonVariable.rg0 = r0;
            return;
        }
    }

    public static void printf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16408;
        int g0 = i7 >> numDefine2;
        r0 = (sp + numDefine4);
        heapClassInst.heap32[fp + numDefineNeg4097] = r0;
        r1 = sp + numDefineNeg16384;
        r2 = heapClassInst.heap32[fp];
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = numDefine16384;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        heapClassInst.heap32[g0 + numDefine3] = r0;
        r0 = gMsgcallback;
        r0 = r0 >> numDefine2;
        vsnprintf(i7);
        r0 = heapClassInst.heap32[r0];
        if (!(r0 == 0)) {
            heapClassInst.heap32[g0] = r1;
            sandboxOutputDebugString(i7);
        }
        return;
    }

    public static void sandboxOutputDebugString(int sp){
        puts(sp);
    }

    public static void puts(int sp) {
        int addr = heapClassInst.heapU32[sp >> numDefine2];
        String name = getStringFromPtr(addr);
        name += '\n';
        dump(name);
    }

    public static String getStringFromPtr(int ptr){
        String ret = "";
        if (ptr == 0) {
            return ret;
        }
        int i = 0;
        while (true) {
            if (heapClassInst.heapU8[ptr + i] == 0) {
                break;
            }
            String t = String.valueOf(heapClassInst.heapU8[ptr + i]);
            ret += t;
            i += 1;
        }
        return ret;
    }

    public static void strtol(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap8[r0];
        r2 = r1 << numDefine2;
        r3 = myCtype;
        r2 = (r2 + r3) | 0;
        r4 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heapU8[r2 + numDefine4];
        r2 = r2 & numDefine8;
        if (r2 == 0) {
            r2 = r0;
        } else {
            r2 = r0;
            repeat4: while (true) {
                r1 = heapClassInst.heap8[r2 + 1];
                r5 = r1 << numDefine2;
                r5 = (r5 + r3) | 0;
                r2 = (r2 + 1) | 0;
                r5 = heapClassInst.heapU8[r5 + numDefine4];
                r5 = r5 & numDefine8;
                if (r5 != 0) {
                    continue repeat4;
                } else {
                    break repeat4;
                }
            }
        }
        r1 = r1 & numDefine255;
        if (r1 == numDefine45) {
            r1 = heapClassInst.heap8[r2 + 1];
            r1 = r1 << numDefine2;
            r3 = (r1 + r3) | 0;
            r3 = heapClassInst.heapU16[(r3 + numDefine4) >> 1];
            r3 = r3 & numDefine263;
            if (r3 == 0) {
                label = numDefine5;
            } else {
                r2 = (r2 + 1) | 0;
                r3 = -1;
                label = numDefine8;
            }
        } else {
            label = numDefine5;
        }
        if (label == numDefine5) {
            r3 = 0;
        }
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r4;
        strtoul(i7);
        r1 = commonVariable.rg0;
        if (!(r4 == 0)) {
            r4 = r4 >> numDefine2;
            r5 = heapClassInst.heap32[r4];
            if (!(r5 != r2)) {
                heapClassInst.heap32[r4] = r0;
            }
        }
        if (r1 > -1) {
            r0 = 0;
            r0 = (r0 - r1) | 0;
            r0 = r3 == 0 ? r1 : r0;
            commonVariable.rg0 = r0;
            return;
        } else {
            errno(i7);
            r0 = commonVariable.rg0;
            if (r1 == numDefineNeg83648) {
                if (!(r3 == 0)) {
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r0] = 0;
                    commonVariable.rg0 = r1;
                    return;
                }
            }
            r1 = r0 >> numDefine2;
            r0 = (int) numDefine83647;
            r2 = numDefineNeg83648;
            heapClassInst.heap32[r1] = numDefine34;
            r1 = r3 == 0 ? r0 : r2;
            commonVariable.rg0 = r1;
            return;
        }
    }

    public static void errno(int sp){
        commonVariable.rg0 = llvmErrno;
    }

    public static void strtoul(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap8[r0];
        r2 = r1 << numDefine2;
        r3 = myCtype;
        r2 = (r2 + r3) | 0;
        r4 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heapU8[r2 + numDefine4];
        r2 = r2 & numDefine8;
        if (r2 == 0) {
            r2 = r0;
        } else {
            r2 = r0;
            repeat4: while (true) {
                r1 = heapClassInst.heap8[r2 + 1];
                r5 = r1 << numDefine2;
                r5 = (r5 + r3) | 0;
                r2 = (r2 + 1) | 0;
                r5 = heapClassInst.heapU8[r5 + numDefine4];
                r5 = r5 & numDefine8;
                if (r5 != 0) {
                    continue repeat4;
                } else {
                    break repeat4;
                }
            }
        }
        r1 = r1 & numDefine255;
        if (r1 == numDefine43) {
            r2 = (r2 + 1) | 0;
            r1 = 0;
        } else {
            if (r1 == numDefine45) {
                r2 = (r2 + 1) | 0;
                r1 = 1;
            } else {
                r1 = 0;
            }
        }
        r3 = 0;
        r5 = r3;
        r6 = r3;
        r11 = -1;
        repeat14: while (true) {
            r8 = (r2 - r3) | 0;
            r7 = heapClassInst.heapU8[r8];
            if (r7 == 0) {
                break repeat14;
            } else {
                if (uint(r7) < uint(numDefine65)) {
                    r9 = r7 & numDefine255;
                    r10 = numDefine58;
                    r7 = (r7 + numDefineNeg48) | 0;
                    r7 = uint((int) r9) < uint((int) r10) ? r7 : r11;
                    r7 = r7 & numDefine255;
                    if (uint(r7) > uint(numDefine9)) {
                        break repeat14;
                    } else {
                        r8 = r6 & numDefine255;
                        r8 = (r8 * numDefine10) | 0;
                        r7 = (r7 + r8) | 0;
                        r6 = r6 >>> numDefine8;
                        r8 = r7 >>> numDefine8;
                        r6 = (r6 * numDefine10) | 0;
                        r6 = (r8 + r6) | 0;
                        r8 = (int) numDefine77215;
                        r9 = 1;
                        r10 = r6 << numDefine8;
                        r7 = r7 & numDefine255;
                        r5 = uint(r6) > uint(r8) ? r9 : r5;
                        r6 = r10 | r7;
                        r3 = (r3 + -1) | 0;
                        continue repeat14;
                    }
                } else {
                    break repeat14;
                }
            }
        }
        if (r3 == 0) {
            errno(i7);
            r6 = 0;
            r8 = commonVariable.rg0 >> numDefine2;
            heapClassInst.heap32[r8] = numDefine22;
            r8 = r0;
        }
        if (!(r4 == 0)) {
            r0 = r4 >> numDefine2;
            heapClassInst.heap32[r0] = r8;
        }
        if (r5 == 0) {
            r0 = 0;
            r0 = (r0 - r6) | 0;
            r0 = r1 == 0 ? r6 : r0;
            commonVariable.rg0 = r0;
            return;
        } else {
            errno(i7);
            r1 = commonVariable.rg0 >> numDefine2;
            heapClassInst.heap32[r1] = numDefine34;
            r1 = -1;
            commonVariable.rg0 = r1;
            return;
        }
    }


    public static void  vPrintf(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg184;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg136;
        r1 = heapClassInst.heap32[fp + numDefine2];
        r2 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[fp + 1];
        r0 = (r0 + 1) | 0;
        heapClassInst.heap32[fp + -1] = r1;
        heapClassInst.heap32[fp + numDefineNeg2] = 0;
        repeat1: while (true) {
            r4 = heapClassInst.heapU8[r3];
            if (r4 == 0) {
                label = numDefine197;
                break repeat1;
            } else {
                r1 = 0;
                r5 = r4;
                repeat4: while (true) {
                    r5 = r5 & numDefine255;
                    if (r5 == 0) {
                        break repeat4;
                    } else {
                        if (r5 != numDefine37) {
                            r5 = (r3 - r1) | 0;
                            r5 = heapClassInst.heapU8[r5 + 1];
                            r1 = (r1 + -1) | 0;
                        } else {
                            break repeat4;
                        }
                    }
                }
                r5 = 0;
                if (r1 != 0) {
                    r4 = (r5 - r1) | 0;
                    if (r4 < 0) {
                        label = numDefine198;
                        break repeat1;
                    } else {
                        r6 = heapClassInst.heap32[fp + numDefineNeg2];
                        r7 = (r6 - r1) | 0;
                        if (uint(r7) < uint(r6)) {
                            label = numDefine198;
                            break repeat1;
                        } else {
                            r6 = (r3 - r1) | 0;
                            r7 = r2 >> numDefine2;
                            r8 = heapClassInst.heap32[r7 + 1];
                            r7 = heapClassInst.heap32[r7];
                            heapClassInst.heap32[g0] = r3;
                            heapClassInst.heap32[g0 + 1] = r4;
                            heapClassInst.heap32[g0 + numDefine2] = r7;
                            functionTable.get(r8 >> numDefine2).accept(i7);
                            r4 = heapClassInst.heap32[fp + numDefineNeg2];
                            r4 = (r4 - r1) | 0;
                            r1 = (r3 - r1) | 0;
                            heapClassInst.heap32[fp + numDefineNeg2] = r4;
                            r4 = heapClassInst.heapU8[r1];
                            r3 = r6;
                        }
                    }
                }
                r1 = r4 & numDefine255;
                if (r1 != numDefine37) {
                    continue repeat1;
                } else {
                    r3 = (r3 + 1) | 0;
                    r1 = numDefine32;
                    r4 = r5;
                    r6 = r5;
                    r7 = r5;
                    r8 = r5;
                    r9 = r5;
                    r10 = r5;
                    r11 = r5;
                    repeat15: while (true) {
                        r12 = r4;
                        r13 = r3;
                        r14 = heapClassInst.heapU8[r13];
                        r3 = (r13 + 1) | 0;
                        heapClassInst.heap8[sp + numDefineNeg145] = (byte)(byte) r14;
                        repeat17: do {
                            if (r14 > numDefine99) {
                                if (r14 > numDefine110) {
                                    if (r14 > numDefine114) {
                                        if (r14 > numDefine119) {
                                            if (r14 == numDefine122) {
                                                label = numDefine50;
                                                break repeat17;
                                            } else {
                                                label = numDefine44;
                                                break repeat15;
                                            }
                                        } else {
                                            label = numDefine41;
                                            break repeat15;
                                        }
                                    } else {
                                        if (r14 == numDefine111) {
                                            label = numDefine99;
                                            break repeat15;
                                        } else {
                                            if (r14 == numDefine112) {
                                                label = numDefine91;
                                                break repeat15;
                                            } else {
                                                if (r14 == numDefine113) {
                                                    label = numDefine49;
                                                    break repeat17;
                                                } else {
                                                    continue repeat1;
                                                }
                                            }
                                        }
                                    }
                                } else {
                                    if (r14 > numDefine104) {
                                        if (r14 == numDefine105) {
                                            label = numDefine102;
                                            break repeat15;
                                        } else {
                                            if (r14 == numDefine106) {
                                                label = numDefine49;
                                                break repeat17;
                                            } else {
                                                if (r14 == numDefine108) {
                                                    label = numDefine50;
                                                    break repeat17;
                                                } else {
                                                    continue repeat1;
                                                }
                                            }
                                        }
                                    } else {
                                        if (r14 == numDefine100) {
                                            label = numDefine102;
                                            break repeat15;
                                        } else {
                                            r4 = (r14 + numDefineNeg102)|0;
                                            if (uint(r4) < uint(numDefine2)) {
                                                label = numDefine129;
                                                break repeat15;
                                            } else {
                                                if (r14 == numDefine104) {
                                                    label = numDefine48;
                                                    break repeat17;
                                                } else {
                                                    continue repeat1;
                                                }
                                            }
                                        }
                                    }
                                }
                            } else {
                                if (r14 > numDefine44) {
                                    if (r14 > numDefine75) {
                                        if (r14 > numDefine97) {
                                            label = numDefine26;
                                            break repeat15;
                                        } else {
                                            if (r14 == numDefine76) {
                                                label = numDefine49;
                                                break repeat17;
                                            } else {
                                                label = numDefine25;
                                                break repeat15;
                                            }
                                        }
                                    } else {
                                        r4 = 1;
                                        if (r14 == numDefine45) {
                                            continue repeat15;
                                        } else {
                                            if (r14 == numDefine46) {
                                                r4 = heapClassInst.heapU8[r3];
                                                if (r4 != numDefine42) {
                                                    r4 = sp + numDefineNeg144;
                                                    heapClassInst.heap32[g0] = r3;
                                                    heapClassInst.heap32[g0 + 1] = r4;
                                                    strtol(i7);
                                                    r14 = 0;
                                                    r11 = commonVariable.rg0 < 0 ? r14 : commonVariable.rg0;
                                                    r3 = heapClassInst.heap32[fp + numDefineNeg36];
                                                } else {
                                                    r4 = sp + numDefineNeg4;
                                                    heapClassInst.heap32[g0] = r4;
                                                    heapClassInst.heap32[g0 + 1] = numDefine4;
                                                    myArgTest(i7);
                                                    r4 = commonVariable.rg0 >> numDefine2;
                                                    r4 = heapClassInst.heap32[r4];
                                                    r14 = 0;
                                                    r11 = r4 < 0 ? r14 : r4;
                                                    r3 = (r13 + numDefine2) | 0;
                                                }
                                                r8 = 1;
                                                r4 = r12;
                                                if (uint(r11) > uint(numDefine10240)) {
                                                    label = numDefine198;
                                                    break repeat1;
                                                } else {
                                                    continue repeat15;
                                                }
                                            } else {
                                                r4 = (r14 + numDefineNeg48) | 0;
                                                if (uint(r4) < uint(numDefine10)) {
                                                    r4 = r8 & numDefine255;
                                                    if (r4 != 0) {
                                                        label = numDefine198;
                                                        break repeat1;
                                                    } else {
                                                        r4 = sp + numDefineNeg144;
                                                        heapClassInst.heap32[g0] = r13;
                                                        heapClassInst.heap32[g0 + 1] = r4;
                                                        strtoul(i7);
                                                        r10 = commonVariable.rg0;
                                                        if (uint(r10) > uint(numDefine10240)) {
                                                            label = numDefine198;
                                                            break repeat1;
                                                        } else {
                                                            r8 = 0;
                                                            r4 = r12 & numDefine255;
                                                            r13 = heapClassInst.heapU8[sp + numDefineNeg145];
                                                            r14 = numDefine48;

                                                            r13 = r13 == r14 ? 1 : 0;

                                                            r4 = r4 == r8 ? 1 : 0;
                                                            r4 = r13 & r4;
                                                            r1 = r4 != 0 ? r14 : r1;
                                                            r3 = heapClassInst.heap32[fp + numDefineNeg36];
                                                            r4 = r12;
                                                            continue repeat15;
                                                        }
                                                    }
                                                } else {
                                                    continue repeat1;
                                                }
                                            }
                                        }
                                    }
                                } else {
                                    if (r14 > numDefine36) {
                                        if (r14 == numDefine37) {
                                            label = numDefine62;
                                            break repeat15;
                                        } else {
                                            if (r14 == numDefine42) {
                                                r4 = sp + numDefineNeg4;
                                                heapClassInst.heap32[g0] = r4;
                                                heapClassInst.heap32[g0 + 1] = numDefine4;
                                                myArgTest(i7);
                                                r4 = commonVariable.rg0 >> numDefine2;
                                                r4 = heapClassInst.heap32[r4];
                                                r13 = r4 >> numDefine31;
                                                r14 = (r4 + r13) | 0;
                                                r15 = 1;
                                                r10 = r14 ^ r13;
                                                r4 = r4 < 0 ? r15 : r12;
                                                if (uint(r10) > uint(numDefine10240)) {
                                                    label = numDefine198;
                                                    break repeat1;
                                                } else {
                                                    continue repeat15;
                                                }
                                            } else {
                                                if (r14 == numDefine43) {
                                                    r7 = 1;
                                                    r4 = r12;
                                                    continue repeat15;
                                                } else {
                                                    continue repeat1;
                                                }
                                            }
                                        }
                                    } else {
                                        if (r14 == 0) {
                                            label = numDefine198;
                                            break repeat1;
                                        } else {
                                            if (r14 == numDefine32) {
                                                r6 = 1;
                                                r4 = r12;
                                                continue repeat15;
                                            } else {
                                                if (r14 == numDefine35) {
                                                    r5 = numDefine255;
                                                    label = numDefine48;
                                                } else {
                                                    continue repeat1;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        } while (false);
                        switch (label) {
                            case numDefine49:
                                r9 = (r9 + 1) | 0;
                                break;
                            case numDefine48:
                                r9 = (r9 + -1) | 0;
                                r4 = r12;
                                continue repeat15;
                            default:
                                break;
                        }
                        r9 = (r9 + 1) | 0;
                        r4 = r12;
                    }
                    repeat71: do {
                        switch (label) {
                            case numDefine26:
                                if (r14 == numDefine98) {
                                    r4 = 0;
                                    r13 = numDefine2;
                                    r14 = r4;
                                    r15 = r4;
                                    label = numDefine104;
                                    break repeat71;
                                } else {
                                    if (r14 == numDefine99) {
                                        r1 = sp + numDefineNeg4;
                                        heapClassInst.heap32[g0] = r1;
                                        heapClassInst.heap32[g0 + 1] = numDefine4;
                                        myArgTest(i7);
                                        r1 = commonVariable.rg0 >> numDefine2;
                                        r1 = heapClassInst.heap32[r1];
                                        heapClassInst.heap8[sp + numDefineNeg145] = (byte)(byte) r1;
                                        label = numDefine62;
                                        break repeat71;
                                    } else {
                                        continue repeat1;
                                    }
                                }

                            case numDefine25:
                                if (r14 == numDefine88) {
                                    label = numDefine92;
                                    break repeat71;
                                } else {
                                    continue repeat1;
                                }
                            case numDefine44:
                                if (r14 != numDefine120) {
                                    continue repeat1;
                                } else {
                                    r4 = 0;
                                    label = numDefine93;
                                    break repeat71;
                                }
                            case numDefine41:
                                if (r14 == numDefine115) {
                                    r1 = sp + numDefineNeg4;
                                    heapClassInst.heap32[g0] = r1;
                                    heapClassInst.heap32[g0 + 1] = numDefine4;
                                    myArgTest(i7);
                                    r1 = commonVariable.rg0 >> numDefine2;
                                    r4 = twoEStr38684;
                                    r1 = heapClassInst.heap32[r1];
                                    r1 = r1 == 0 ? r4 : r1;
                                    heapClassInst.heap32[fp + numDefineNeg36] = r1;
                                    r4 = heapClassInst.heapU8[r1];
                                    repeat83: do {
                                        if (r4 != 0) {
                                            r4 = (r1 + 1) | 0;
                                            r14 = 0;
                                            while (true) {
                                                r1 = (r14 + 1) | 0;
                                                r6 = heapClassInst.heapU8[r4 + r14];
                                                r14 = r1;
                                                if (!(r6 != 0)) {
                                                    break repeat83;
                                                }
                                            }
                                        } else {
                                            r1 = 0;
                                        }
                                    } while (false);
                                    r16 = 0;
                                    r4 = r8 & numDefine255;

                                    r4 = r4 != r16 ? 1 : 0;

                                    r14 = uint(r1) > uint(r11) ? 1 : 0;
                                    r4 = r4 & r14;
                                    r14 = numDefine32;
                                    r4 = r4 != 0 ? r11 : r1;
                                    r1 = r14;
                                    r8 = r16;
                                    r11 = r16;
                                    label = numDefine69;
                                    break repeat71;
                                } else {
                                    if (r14 == numDefine117) {
                                        r4 = 0;
                                        r13 = numDefine10;
                                        r14 = r4;
                                        r15 = r4;
                                        label = numDefine104;
                                        break repeat71;
                                    } else {
                                        continue repeat1;
                                    }
                                }

                            case numDefine99:
                                r4 = r5 & numDefine255;
                                if (r4 != 0) {
                                    r5 = 1;
                                    r4 = 0;
                                    r13 = numDefine8;
                                    r14 = numDefine48;
                                    heapClassInst.heap8[sp + numDefineNeg135] = (byte)(byte)r14;
                                    r14 = r4;
                                    r15 = r5;
                                    label = numDefine104;
                                    break repeat71;
                                } else {
                                    r4 = 0;
                                    r13 = numDefine8;
                                    r14 = r4;
                                    r5 = r4;
                                    r15 = r4;
                                    label = numDefine104;
                                    break repeat71;
                                }
                            case numDefine91:
                                r14 = numDefine120;
                                r5 = numDefine2;
                                r9 = 1;
                                heapClassInst.heap8[sp + numDefineNeg145] = (byte)(byte) r14;
                                label = numDefine92;
                                break repeat71;
                            case numDefine102:
                                r4 = 0;
                                r14 = 1;
                                r13 = numDefine10;
                                r15 = r4;
                                label = numDefine104;
                                break repeat71;
                            case numDefine129:
                                r4 = sp + numDefineNeg4;
                                heapClassInst.heap32[g0] = r4;
                                heapClassInst.heap32[g0 + 1] = numDefine8;
                                myArgTest(i7);
                                f0 = llvmReadDouble(commonVariable.rg0);
                                heapClassInst.heap32[fp + numDefineNeg36] = r0;
                                r4 = numDefine103;

                                r4 = r14 == r4 ? 1 : 0;
                                r8 = r8 & numDefine255;
                                r16 = 1;
                                r9 = numDefine6;
                                r10 = r10 == 0 ? r16 : r10;
                                r11 = r8 == 0 ? r9 : r11;
                                r4 = r4 & 1;
                                f1 = 0;
                                r9 = r7 & numDefine255;
                                r13 = 0;
                                llvmWriteDouble(i7, (int) f0);
                                heapClassInst.heap32[g0 + numDefine2] = r0;
                                heapClassInst.heap32[g0 + numDefine3] = numDefine127;
                                heapClassInst.heap32[g0 + numDefine4] = r10;
                                heapClassInst.heap32[g0 + numDefine5] = r11;
                                heapClassInst.heap32[g0 + numDefine6] = r4;

                                r4 = r9 != r13 ? 1 : 0;

                                r16 = f0 < f1 ? 1 : 0;
                                r4 = r4 | r16;
                                r16 = r4 & 1;
                                dtostr(i7);
                                r4 = commonVariable.rg0;
                                repeat98: do {
                                    if (r8 != 0) {
                                        r8 = heapClassInst.heap32[fp + numDefineNeg36];
                                        r15 = r13;
                                        repeat100: while (true) {
                                            r17 = heapClassInst.heapU8[r8 + r13];
                                            if (r17 == 0) {
                                                label = numDefine151;
                                                break repeat100;
                                            } else {
                                                r18 = (r8 + r13) | 0;
                                                if (r17 == numDefine46) {
                                                    label = numDefine142;
                                                    break repeat100;
                                                } else {
                                                    r17 = heapClassInst.heapU8[r18 + 1];
                                                    if (r17 == 0) {
                                                        label = numDefine151;
                                                        break repeat100;
                                                    } else {
                                                        r19 = r15 << numDefine2;
                                                        if (r17 != numDefine46) {
                                                            r17 = heapClassInst.heapU8[r18 + numDefine2];
                                                            if (r17 == 0) {
                                                                label = numDefine151;
                                                                break repeat100;
                                                            } else {
                                                                if (r17 != numDefine46) {
                                                                    r17 = heapClassInst.heapU8[r18 + numDefine3];
                                                                    if (r17 == 0) {
                                                                        label = numDefine151;
                                                                        break repeat100;
                                                                    } else {
                                                                        if (r17 == numDefine46) {
                                                                            label = numDefine143;
                                                                            break repeat100;
                                                                        } else {
                                                                            r15 = (r15 + 1) | 0;
                                                                            r13 = (r13 + numDefine4) | 0;
                                                                        }
                                                                    }
                                                                } else {
                                                                    label = numDefine138;
                                                                    break repeat100;
                                                                }
                                                            }
                                                        } else {
                                                            label = numDefine135;
                                                            break repeat100;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        repeat110: do {
                                            switch (label) {
                                                case numDefine142:
                                                    if (r18 == 0) {
                                                        label = numDefine151;
                                                        break repeat110;
                                                    } else {
                                                        label = numDefine144;
                                                        break repeat110;
                                                    }
                                                case numDefine143:
                                                    r18 = (r18 + numDefine3) | 0;
                                                    label = numDefine144;
                                                    break repeat110;
                                                case numDefine138:
                                                    r4 = r19 | numDefine2;
                                                    r18 = (r8 + r4) | 0;
                                                    label = numDefine144;
                                                    break repeat110;
                                                case numDefine135:
                                                    r4 = r19 | 1;
                                                    r18 = (r8 + r4) | 0;
                                                    label = numDefine144;
                                                    break;
                                                default:
                                                    break;
                                            }
                                        } while (false);
                                        switch (label) {
                                            case numDefine151:
                                                r5 = r5 & numDefine255;
                                                if (r5 == 0) {
                                                    break repeat98;
                                                } else {
                                                    r5 = numDefine46;
                                                    heapClassInst.heap8[r8 + r4] = (byte)r5;
                                                    r5 = heapClassInst.heap32[fp + numDefineNeg36];
                                                    r4 = (r4 + r5) | 0;
                                                    r5 = 0;
                                                    heapClassInst.heap8[r4 + 1] = (byte)r5;
                                                }

                                            case numDefine144:
                                                if (r11 != 0) {
                                                    label = numDefine146;
                                                } else {
                                                    r4 = r5 & numDefine255;
                                                    if (r4 != 0) {
                                                        label = numDefine146;
                                                    } else {
                                                        label = numDefine147;
                                                    }
                                                }
                                                if (label == numDefine146) {
                                                    r18 = (r18 + 1) | 0;
                                                }
                                                repeat123: while (true) {
                                                    r4 = r11;
                                                    if (r4 != 0) {
                                                        r11 = (r4 + -1) | 0;
                                                        r5 = (r18 + 1) | 0;
                                                        r8 = heapClassInst.heapU8[r18 + 1];
                                                        r18 = r5;
                                                        if (r8 != 0) {
                                                            label = numDefine147;
                                                        } else {
                                                            label = numDefine149;
                                                            break repeat123;
                                                        }
                                                    } else {
                                                        label = numDefine150;
                                                        break repeat123;
                                                    }
                                                }
                                                if (label == numDefine149) {
                                                    r18 = r5;
                                                }
                                                r5 = 0;
                                                heapClassInst.heap8[r18] = (byte)r5;
                                                r11 = r4;
                                            default:
                                                break;
                                        }
                                    }
                                } while (false);
                                repeat130: do {
                                    if (!(r14 != numDefine103)) {
                                        r4 = heapClassInst.heap32[fp + numDefineNeg36];
                                        r5 = 0;
                                        r8 = r5;
                                        repeat132: while (true) {
                                            r14 = heapClassInst.heapU8[r4 + r5];
                                            if (r14 == 0) {
                                                break repeat130;
                                            } else {
                                                r13 = (r4 + r5) | 0;
                                                if (r14 == numDefine46) {
                                                    label = numDefine166;
                                                    break repeat132;
                                                } else {
                                                    r14 = heapClassInst.heapU8[r13 + 1];
                                                    if (r14 == 0) {
                                                        break repeat130;
                                                    } else {
                                                        r15 = r8 << numDefine2;
                                                        if (r14 != numDefine46) {
                                                            r14 = heapClassInst.heapU8[r13 + numDefine2];
                                                            if (r14 == 0) {
                                                                break repeat130;
                                                            } else {
                                                                if (r14 != numDefine46) {
                                                                    r14 = heapClassInst.heapU8[r13 + numDefine3];
                                                                    if (r14 == 0) {
                                                                        break repeat130;
                                                                    } else {
                                                                        if (r14 == numDefine46) {
                                                                            label = numDefine167;
                                                                            break repeat132;
                                                                        } else {
                                                                            r8 = (r8 + 1) | 0;
                                                                            r5 = (r5 + numDefine4) | 0;
                                                                        }
                                                                    }
                                                                } else {
                                                                    label = numDefine162;
                                                                    break repeat132;
                                                                }
                                                            }
                                                        } else {
                                                            label = numDefine159;
                                                            break repeat132;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        switch (label) {
                                            case numDefine166:
                                                if (r13 == 0) {
                                                    break repeat130;
                                                }

                                            case numDefine167:
                                                r13 = (r13 + numDefine3) | 0;
                                                break;
                                            case numDefine162:
                                                r5 = r15 | numDefine2;
                                                r13 = (r4 + r5) | 0;
                                                break;
                                            case numDefine159:
                                                r5 = r15 | 1;
                                                r13 = (r4 + r5) | 0;
                                                break;
                                            default:
                                                break;
                                        }
                                        r4 = 0;
                                        r5 = r13;
                                        repeat148: while (true) {
                                            r8 = heapClassInst.heapU8[r5];
                                            if (r8 != numDefine101) {
                                                if (r8 != 0) {
                                                    r8 = r4 << numDefine2;
                                                    r14 = heapClassInst.heapU8[r5 + 1];
                                                    if (r14 != numDefine101) {
                                                        if (r14 == 0) {
                                                            label = numDefine171;
                                                            break repeat148;
                                                        } else {
                                                            r14 = heapClassInst.heapU8[r5 + numDefine2];
                                                            if (r14 != numDefine101) {
                                                                if (r14 == 0) {
                                                                    label = numDefine171;
                                                                    break repeat148;
                                                                } else {
                                                                    r14 = heapClassInst.heapU8[r5 + numDefine3];
                                                                    if (r14 != numDefine101) {
                                                                        if (r14 == 0) {
                                                                            label = numDefine171;
                                                                            break repeat148;
                                                                        } else {
                                                                            r4 = (r4 + 1) | 0;
                                                                            r5 = (r5 + numDefine4) | 0;
                                                                        }
                                                                    } else {
                                                                        label = numDefine179;
                                                                        break repeat148;
                                                                    }
                                                                }
                                                            } else {
                                                                label = numDefine176;
                                                                break repeat148;
                                                            }
                                                        }
                                                    } else {
                                                        label = numDefine173;
                                                        break repeat148;
                                                    }
                                                } else {
                                                    label = numDefine171;
                                                    break repeat148;
                                                }
                                            } else {
                                                label = numDefine182;
                                                break repeat148;
                                            }
                                        }
                                        switch (label) {
                                            case numDefine171:
                                                r5 = 0;
                                                break;
                                            case numDefine179:
                                                r4 = r8 | numDefine3;
                                                r5 = (r13 + r4) | 0;
                                                break;
                                            case numDefine176:
                                                r4 = r8 | numDefine2;
                                                r5 = (r13 + r4) | 0;
                                                break;
                                            case numDefine173:
                                                r4 = r8 | 1;
                                                r5 = (r13 + r4) | 0;
                                                break;
                                            default:
                                                break;
                                        }
                                        repeat163: while (true) {
                                            r4 = (r13 + 1) | 0;
                                            r8 = heapClassInst.heapU8[r13 + 1];
                                            r13 = r4;
                                            if (!(r8 != 0)) {
                                                break repeat163;
                                            }
                                        }
                                        r4 = r5 == 0 ? r4 : r5;
                                        repeat166: while (true) {
                                            r8 = heapClassInst.heapU8[r4 + -1];
                                            r4 = (r4 + -1) | 0;
                                            if (!(r8 == numDefine48)) {
                                                break repeat166;
                                            }
                                        }
                                        r14 = (r4 + 1) | 0;
                                        r4 = r8 == numDefine46 ? r4 : r14;
                                        r8 = 0;
                                        heapClassInst.heap8[r4] = (byte)r8;
                                        if (!(r5 == 0)) {
                                            heapClassInst.heap32[g0] = r4;
                                            heapClassInst.heap32[g0 + 1] = r5;
                                            strcpy(i7);
                                        }
                                    }
                                } while (false);
                                r4 = r7 | r6;
                                r4 = r4 & numDefine255;
                                if (!(r4 == 0)) {
                                    if (!(f0 < f1)) {
                                        r4 = heapClassInst.heap32[fp + numDefineNeg36];
                                        r5 = (r4 + -1) | 0;
                                        r8 = numDefine32;
                                        r14 = numDefine43;
                                        r8 = r9 == 0 ? r8 : r14;
                                        heapClassInst.heap32[fp + numDefineNeg36] = r5;
                                        heapClassInst.heap8[r4 + -1] = (byte)r8;
                                    }
                                }
                                r4 = heapClassInst.heap32[fp + numDefineNeg36];
                                r5 = heapClassInst.heapU8[r4];
                                repeat175: do {
                                    if (r5 != 0) {
                                        r5 = (r4 + 1) | 0;
                                        r8 = 0;
                                        while (true) {
                                            r4 = (r8 + 1) | 0;
                                            r14 = heapClassInst.heapU8[r5 + r8];
                                            r8 = r4;
                                            if (!(r14 != 0)) {
                                                break repeat175;
                                            }
                                        }
                                    } else {
                                        r4 = 0;
                                    }
                                } while (false);
                                r10 = uint(r10) < uint(r4) ? r4 : r10;
                                r14 = numDefine48;
                                r5 = 0;
                                r8 = r5;
                                label = numDefine69;
                            default:
                                break;
                        }
                    } while (false);
                    switch (label) {
                        case numDefine62:
                            r1 = heapClassInst.heap32[fp + numDefineNeg2];
                            if (r1 == -1) {
                                label = numDefine198;
                                break repeat1;
                            } else {
                                r1 = r2 >> numDefine2;
                                r4 = heapClassInst.heap32[r1 + 1];
                                r1 = heapClassInst.heap32[r1];
                                r5 = sp + numDefineNeg145;
                                heapClassInst.heap32[g0] = r5;
                                heapClassInst.heap32[g0 + 1] = 1;
                                heapClassInst.heap32[g0 + numDefine2] = r1;
                                functionTable.get(r4 >> numDefine2).accept(i7);
                                r1 = heapClassInst.heap32[fp + numDefineNeg2];
                                r1 = (r1 + 1) | 0;
                                heapClassInst.heap32[fp + numDefineNeg2] = r1;
                                continue repeat1;
                            }
                        case numDefine92:
                            r4 = r14 & numDefine255;
                            r13 = numDefine88;

                            r4 = r4 == r13 ? 1 : 0;
                            r4 = r4 & 1;
                            label = numDefine93;
                            break;
                        default:
                            break;
                    }
                    if (label == numDefine93) {
                        r5 = r5 & numDefine255;
                        if (r5 != 0) {
                            r13 = numDefine48;
                            r5 = numDefine2;
                            heapClassInst.heap8[sp + numDefineNeg135] = (byte)r13;
                            heapClassInst.heap8[sp + numDefineNeg134] = (byte)r14;
                            r15 = r5;
                        } else {
                            r5 = 0;
                            r15 = r5;
                        }
                        if (uint(r11) > uint(r10)) {
                            r14 = 0;
                            r13 = numDefine16;
                            r10 = r11;
                            label = numDefine104;
                        } else {
                            r14 = 0;
                            r13 = numDefine16;
                            label = numDefine104;
                        }
                    }
                    repeat194: do {
                        if (label == numDefine104) {
                            heapClassInst.heap32[fp + numDefineNeg36] = r0;
                            r16 = sp + numDefineNeg4;
                            heapClassInst.heap32[g0] = r16;
                            heapClassInst.heap32[g0 + 1] = numDefine4;
                            myArgTest(i7);
                            r17 = commonVariable.rg0 >> numDefine2;
                            r18 = r14 & numDefine255;
                            r16 = 0;
                            r17 = heapClassInst.heap32[r17];

                            r18 = r18 != r16 ? 1 : 0;

                            r19 = r17 < r16 ? 1 : 0;
                            r20 = (r16 - r17) | 0;
                            r18 = r18 & r19;
                            r9 = r9 << numDefine24;
                            r17 = r18 != 0 ? r20 : r17;
                            r9 = r9 >> numDefine24;
                            r19 = r17 & numDefine65535;
                            r17 = r9 < 0 ? r19 : r17;
                            r19 = heapClassInst.heap32[fp + numDefineNeg36];
                            r20 = r17 & numDefine255;
                            r21 = numDefine2;
                            r9 = r9 < -1 ? r20 : r17;
                            r17 = r18 != 0 ? r21 : r14;
                            r14 = (r19 + r15) | 0;
                            heapClassInst.heap8[r14 + numDefine122] = (byte)r16;
                            if (r9 != 0) {
                                r18 = (r13 + -1) | 0;
                                r19 = numDefine35;
                                r20 = numDefine10;
                                r18 = uint(r18) > uint(r19) ? r20 : r13;
                                r4 = r4 & numDefine255;
                                r13 = numDefine39;
                                r19 = numDefine7;
                                r4 = r4 == 0 ? r13 : r19;
                                r19 = (r15 + numDefine121) | 0;
                                r20 = numDefineNeg122;
                                repeat198: while (true) {
                                    r13 = (int) Math.floor(uint(r9) % uint(r18));
                                    r13 = (r13 + numDefine48) | 0;
                                    r22 = r13 & numDefine255;
                                    r23 = numDefine57;
                                    r22 = uint(r22) > uint(r23) ? r4 : r16;
                                    r23 = (r20 + 1) | 0;
                                    r13 = (r13 + r22) | 0;
                                    r20 = (r14 - r20) | 0;
                                    heapClassInst.heap8[r20 + -1] = (byte)r13;
                                    if (r19 <= r15) {
                                        break repeat198;
                                    } else {
                                        r9 = (int) Math.floor(uint(r9) / uint(r18));
                                        r19 = (r19 + -1) | 0;
                                        r20 = r23;
                                        if (!(r9 != 0)) {
                                            break repeat198;
                                        }
                                    }
                                }
                                r18 = (r23 + numDefine122) | 0;
                                r9 = (r14 - r23) | 0;
                            } else {
                                r4 = (r15 + r19) | 0;
                                r13 = numDefine48;
                                r9 = (r4 + numDefine121) | 0;
                                r18 = 1;
                                heapClassInst.heap8[r4 + numDefine121] = (byte)r13;
                            }
                            repeat204: do {
                                if (!(r9 == r14)) {
                                    if (uint(r9) <= uint(r14)) {
                                        if (!(r18 == -1)) {
                                            r4 = (r16 - r18) | 0;
                                            while (true) {
                                                r13 = r4;
                                                r19 = (r9 - r13) | 0;
                                                r4 = (r13 + 1) | 0;
                                                r20 = (r14 - r13) | 0;
                                                r19 = heapClassInst.heapU8[r19];
                                                heapClassInst.heap8[r20] = (byte)r19;
                                                if (!(r13 != 0)) {
                                                    break repeat204;
                                                }
                                            }
                                        }
                                    } else {
                                        if (!(r18 == -1)) {
                                            r4 = (r9 + 1) | 0;
                                            r9 = r18;
                                            while (true) {
                                                heapClassInst.heap8[r14] = (byte)r13;
                                                if (r9 == 0) {
                                                    break repeat204;
                                                } else {
                                                    r13 = heapClassInst.heapU8[r4];
                                                    r4 = (r4 + 1) | 0;
                                                    r9 = (r9 + -1) | 0;
                                                    r14 = (r14 + 1) | 0;
                                                }
                                            }
                                        }
                                    }
                                }
                            } while (false);
                            r4 = 1;

                            r4 = r18 != r4 ? 1 : 0;
                            r4 = r4 & 1;
                            r14 = r8 ^ 1;
                            r4 = r4 | r14;
                            r4 = r4 & numDefine255;
                            if (r4 != 0) {
                                label = numDefine122;
                            } else {
                                r4 = heapClassInst.heap32[fp + numDefineNeg36];
                                r4 = heapClassInst.heapU8[r4 + r15];
                                if (r4 != numDefine48) {
                                    label = numDefine122;
                                } else {
                                    r4 = r5 << numDefine24;
                                    r5 = 0;

                                    r4 = r4 >> numDefine24;

                                    r14 = r11 == r5 ? 1 : 0;

                                    r4 = r4 > r5 ? 1 : 0;
                                    r4 = r14 | r4;
                                    r4 = r4 != 0 ? r5 : r15;
                                    label = numDefine123;
                                }
                            }
                            if (label == numDefine122) {
                                r4 = (r18 + r15) | 0;
                            }
                            r14 = r17 & numDefine255;
                            if (r14 == numDefine2) {
                                r6 = heapClassInst.heap32[fp + numDefineNeg36];
                                r7 = (r6 + -1) | 0;
                                r4 = (r4 + 1) | 0;
                                r14 = numDefine48;
                                r16 = numDefine45;
                                heapClassInst.heap32[fp + numDefineNeg36] = r7;
                                heapClassInst.heap8[r6 + -1] = (byte)r16;
                                r16 = r21;
                            } else {
                                if (r14 != 0) {
                                    r14 = r7 | r6;
                                    r14 = r14 & numDefine255;
                                    if (!(r14 == 0)) {
                                        r6 = heapClassInst.heap32[fp + numDefineNeg36];
                                        r16 = (r6 + -1) | 0;
                                        r7 = r7 & numDefine255;
                                        r9 = numDefine32;
                                        r13 = numDefine43;
                                        r4 = (r4 + 1) | 0;
                                        r14 = numDefine48;
                                        r7 = r7 == 0 ? r9 : r13;
                                        heapClassInst.heap32[fp + numDefineNeg36] = r16;
                                        heapClassInst.heap8[r6 + -1] = (byte)r7;
                                        r16 = r17;
                                        break repeat194;
                                    }
                                }
                                r14 = numDefine48;
                            }
                        }
                    } while (false);
                    r6 = heapClassInst.heap32[fp + numDefineNeg36];
                    r7 = r11 | r10;
                    if (r7 != 0) {
                        r7 = 0;
                        r5 = r5 << numDefine24;
                        r5 = r5 >> numDefine24;
                        if (r5 < 1) {
                            r9 = r16 & numDefine255;

                            r5 = r9 != r7 ? 1 : 0;
                            r5 = r5 & 1;
                            if (r9 != 0) {
                                label = numDefine75;
                            } else {
                                label = numDefine76;
                            }
                        } else {
                            label = numDefine75;
                        }
                        if (label == numDefine75) {
                            r4 = (r4 - r5) | 0;
                            r10 = (r10 - r5) | 0;
                            r9 = (r6 + r5) | 0;
                            heapClassInst.heap32[fp + numDefineNeg36] = r9;
                        }
                        r8 = r8 & numDefine255;

                        r9 = r8 != r7 ? 1 : 0;

                        r7 = r10 == r7 ? 1 : 0;
                        r7 = r9 & r7;
                        r7 = r7 != 0 ? r11 : r10;
                        r8 = r8 == 0 ? r4 : r11;
                        r9 = r12 & numDefine255;
                        if (!(r9 != 0)) {
                            r10 = r1 & numDefine255;
                            if (!(r10 != numDefine32)) {
                                r11 = sp + numDefineNeg8;
                                r12 = (r7 - r8) | 0;
                                heapClassInst.heap32[g0] = r11;
                                heapClassInst.heap32[g0 + 1] = r2;
                                heapClassInst.heap32[g0 + numDefine2] = r12;
                                heapClassInst.heap32[g0 + numDefine3] = r10;
                                writePad(i7);
                                r10 = commonVariable.rg0;
                                if (r10 != 0) {
                                    label = numDefine198;
                                    break repeat1;
                                }
                            }
                        }
                        if (!(r5 == 0)) {
                            if (r5 < 0) {
                                label = numDefine198;
                                break repeat1;
                            } else {
                                r10 = heapClassInst.heap32[fp + numDefineNeg2];
                                r11 = (r10 + r5) | 0;
                                if (uint(r11) < uint(r10)) {
                                    label = numDefine198;
                                    break repeat1;
                                } else {
                                    r10 = r2 >> numDefine2;
                                    r11 = heapClassInst.heap32[r10 + 1];
                                    r10 = heapClassInst.heap32[r10];
                                    heapClassInst.heap32[g0] = r6;
                                    heapClassInst.heap32[g0 + 1] = r5;
                                    heapClassInst.heap32[g0 + numDefine2] = r10;
                                    functionTable.get(r11 >> numDefine2).accept(i7);
                                    r6 = heapClassInst.heap32[fp + numDefineNeg2];
                                    r5 = (r6 + r5) | 0;
                                    heapClassInst.heap32[fp + numDefineNeg2] = r5;
                                }
                            }
                        }
                        if (!(r9 != 0)) {
                            r5 = r1 & numDefine255;
                            if (!(r5 == numDefine32)) {
                                r6 = sp + numDefineNeg8;
                                r10 = (r7 - r8) | 0;
                                heapClassInst.heap32[g0] = r6;
                                heapClassInst.heap32[g0 + 1] = r2;
                                heapClassInst.heap32[g0 + numDefine2] = r10;
                                heapClassInst.heap32[g0 + numDefine3] = r5;
                                writePad(i7);
                                r5 = commonVariable.rg0;
                                if (r5 != 0) {
                                    label = numDefine198;
                                    break repeat1;
                                }
                            }
                        }
                        r5 = sp + numDefineNeg8;
                        r6 = (r8 - r4) | 0;
                        heapClassInst.heap32[g0] = r5;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = r6;
                        heapClassInst.heap32[g0 + numDefine3] = r14;
                        writePad(i7);
                        r14 = commonVariable.rg0;
                        if (r14 != 0) {
                            label = numDefine198;
                            break repeat1;
                        } else {
                            if (r4 < 0) {
                                label = numDefine198;
                                break repeat1;
                            } else {
                                r14 = heapClassInst.heap32[fp + numDefineNeg2];
                                r6 = (r14 + r4) | 0;
                                if (uint(r6) < uint(r14)) {
                                    label = numDefine198;
                                    break repeat1;
                                } else {
                                    r14 = r2 >> numDefine2;
                                    r6 = heapClassInst.heap32[r14 + 1];
                                    r14 = heapClassInst.heap32[r14];
                                    r10 = heapClassInst.heap32[fp + numDefineNeg36];
                                    heapClassInst.heap32[g0] = r10;
                                    heapClassInst.heap32[g0 + 1] = r4;
                                    heapClassInst.heap32[g0 + numDefine2] = r14;
                                    functionTable.get(r6 >> numDefine2).accept(i7);
                                    r14 = heapClassInst.heap32[fp + numDefineNeg2];
                                    r4 = (r14 + r4) | 0;
                                    heapClassInst.heap32[fp + numDefineNeg2] = r4;
                                    if (r9 == 0) {
                                        continue repeat1;
                                    } else {
                                        r4 = (r7 - r8) | 0;
                                        r14 = r1 & numDefine255;
                                        heapClassInst.heap32[g0] = r5;
                                        heapClassInst.heap32[g0 + 1] = r2;
                                        heapClassInst.heap32[g0 + numDefine2] = r4;
                                        heapClassInst.heap32[g0 + numDefine3] = r14;
                                        writePad(i7);
                                        r4 = commonVariable.rg0;
                                        if (r4 == 0) {
                                            continue repeat1;
                                        } else {
                                            label = numDefine198;
                                            break repeat1;
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        if (r4 < 0) {
                            label = numDefine198;
                            break repeat1;
                        } else {
                            r14 = heapClassInst.heap32[fp + numDefineNeg2];
                            r1 = (r14 + r4) | 0;
                            if (uint(r1) < uint(r14)) {
                                label = numDefine198;
                                break repeat1;
                            } else {
                                r14 = r2 >> numDefine2;
                                r1 = heapClassInst.heap32[r14 + 1];
                                r14 = heapClassInst.heap32[r14];
                                heapClassInst.heap32[g0] = r6;
                                heapClassInst.heap32[g0 + 1] = r4;
                                heapClassInst.heap32[g0 + numDefine2] = r14;
                                functionTable.get(r1 >> numDefine2).accept(i7);
                                r14 = heapClassInst.heap32[fp + numDefineNeg2];
                                r4 = (r14 + r4) | 0;
                                heapClassInst.heap32[fp + numDefineNeg2] = r4;
                                continue repeat1;
                            }
                        }
                    }
                }
            }
        }
        switch (label) {
            case numDefine197:
                r0 = heapClassInst.heap32[fp + numDefineNeg2];
                commonVariable.rg0 = r0;
                return;
            case numDefine198:
                r0 = -1;
                commonVariable.rg0 = r0;
                return;
            default:
                break;
        }
    }

    public static void writePad(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        if (r0 > 0) {
            r1 = heapClassInst.heap32[fp];
            r1 = r1 >> numDefine2;
            r2 = heapClassInst.heap32[r1];
            r2 = (r2 + r0) | 0;
            if (uint(r2) >= uint(r0)) {
                r2 = heapClassInst.heap32[fp + 1];
                r3 = heapClassInst.heap32[fp + numDefine3];
                if (uint(r0) > uint(numDefine15)) {
                    r4 = numDefine48;

                    r4 = r3 == r4 ? 1 : 0;
                    r4 = r4 & 1;
                    r5 = zl8padLine;
                    r4 = r4 << numDefine5;
                    r4 = (r5 + r4) | 0;
                    r5 = 0;
                    repeat7: while (true) {
                        r6 = r2 >> numDefine2;
                        r7 = heapClassInst.heap32[r6 + 1];
                        r6 = heapClassInst.heap32[r6];
                        heapClassInst.heap32[g0] = r4;
                        heapClassInst.heap32[g0 + 1] = numDefine16;
                        heapClassInst.heap32[g0 + numDefine2] = r6;
                        r5 = (r5 + numDefineNeg16) | 0;
                        functionTable.get(r7 >> numDefine2).accept(i7);
                        r6 = (r0 + r5) | 0;
                        if (!(uint(r6) > uint(numDefine15))) {
                            break repeat7;
                        }
                    }
                    r0 = 0;
                    r4 = (r0 - r5) | 0;
                    if (r6 == 0) {
                        label = numDefine11;
                    } else {
                        r0 = r6;
                        label = numDefine10;
                    }
                } else {
                    r4 = 0;
                    label = numDefine10;
                }
                if (label == numDefine10) {
                    r5 = numDefine48;
                    r2 = r2 >> numDefine2;

                    r3 = r3 == r5 ? 1 : 0;
                    r3 = r3 & 1;
                    r5 = heapClassInst.heap32[r2 + 1];
                    r2 = heapClassInst.heap32[r2];
                    r6 = zl8padLine;
                    r3 = r3 << numDefine5;
                    r3 = (r6 + r3) | 0;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = r0;
                    heapClassInst.heap32[g0 + numDefine2] = r2;
                    r4 = (r4 + r0) | 0;
                    functionTable.get(r5 >> numDefine2).accept(i7);
                }
                r0 = heapClassInst.heap32[r1];
                r0 = (r0 + r4) | 0;
                heapClassInst.heap32[r1] = r0;
                r0 = 0;
            } else {
                r0 = -1;
            }
        } else {
            r0 = 0;
        }
        commonVariable.rg0 = r0;
        return;
    }

    public static void memcpy(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = r1 ^ r0;
        r3 = r3 & numDefine3;
        repeat1: do {
            if (r3 != 0) {
                label = numDefine2;
            } else {
                if (uint(r2) > uint(numDefine4)) {
                    r3 = r0 & numDefine3;
                    if (r3 != 0) {
                        r3 = (r3 + numDefineNeg5) | 0;
                        r4 = r2 ^ -1;
                        r3 = uint(r3) < uint(r4) ? r4 : r3;
                        r4 = (r3 + r2) | 0;
                        r3 = r3 ^ -1;
                        r4 = (r4 + 1) | 0;
                        r6 = (r1 + r3) | 0;
                        r5 = (r0 + r3) | 0;
                        r3 = r0 | numDefineNeg4;
                        r7 = r0;
                        repeat6: while (true) {
                            if (r3 == 0) {
                                break repeat6;
                            } else {
                                if (r2 == 0) {
                                    label = numDefine19;
                                    break repeat1;
                                } else {
                                    r8 = heapClassInst.heapU8[r1];
                                    r2 = (r2 + -1) | 0;
                                    r3 = (r3 + 1) | 0;
                                    r1 = (r1 + 1) | 0;
                                    r9 = (r7 + 1) | 0;
                                    heapClassInst.heap8[r7] = (byte)r8;
                                    r7 = r9;
                                }
                            }
                        }
                        if (r4 == -1) {
                            label = numDefine19;
                            break repeat1;
                        } else {
                            r2 = r4;
                            r1 = r6;
                        }
                    } else {
                        r5 = r0;
                    }
                    if (uint(r2) > uint(numDefine3)) {
                        r6 = r5;
                        r4 = r1;
                        repeat16: while (true) {
                            r7 = r4 >> numDefine2;
                            r2 = (r2 + numDefineNeg4) | 0;
                            r4 = (r4 + numDefine4) | 0;
                            r3 = (r6 + numDefine4) | 0;
                            r6 = r6 >> numDefine2;
                            r7 = heapClassInst.heap32[r7];
                            heapClassInst.heap32[r6] = r7;
                            r6 = r3;
                            if (uint(r2) > uint(numDefine3)) {
                                continue repeat16;
                            } else {
                                label = numDefine15;
                                break repeat1;
                            }
                        }
                    } else {
                        r4 = r1;
                        r3 = r5;
                        label = numDefine15;
                    }
                } else {
                    label = numDefine2;
                }
            }
        } while (false);
        if (label == numDefine2) {
            r3 = 0;
            r4 = r3;
            r5 = r0;
            label = numDefine15;
        }
        repeat21: do {
            if (label == numDefine15) {
                if (!(r2 == 0)) {
                    if (r3 != 0) {
                        r1 = r4;
                        r5 = r3;
                    }
                    repeat26: while (true) {
                        r3 = heapClassInst.heapU8[r1];
                        r2 = (r2 + -1) | 0;
                        r4 = (r5 + 1) | 0;
                        r1 = (r1 + 1) | 0;
                        heapClassInst.heap8[r5] = (byte)r3;
                        r5 = r4;
                        if (r2 != 0) {
                            continue repeat26;
                        } else {
                            break repeat21;
                        }
                    }
                }
            }
        } while (false);
        commonVariable.rg0 = r0;
        return;
    }


    public static void vsnprintf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg16;
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r2 + 1] = 0;
        r4 = (r1 + -1) | 0;
        r5 = 0;
        r6 = sp + numDefineNeg24;
        r7 = r1 == 0 ? r5 : r4;
        heapClassInst.heap32[fp + numDefineNeg4] = r3;
        r8 = r6 >> numDefine2;
        r9 = swriteIndex.swriteIndexNew;
        heapClassInst.heap32[r2 + numDefine2] = r7;
        heapClassInst.heap32[r8 + 1] = r9;
        heapClassInst.heap32[fp + numDefineNeg6] = r0;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r2 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[g0] = r6;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        vPrintf(i7);
        r0 = commonVariable.rg0;
        if (!(r3 == 0)) {
            if (!(r1 == 0)) {
                if (!(r0 < 0)) {
                    if (!(r1 == -1)) {
                        if (!(uint(r0) < uint(r1))) {
                            heapClassInst.heap8[r3 + r4] = (byte)r5;
                            commonVariable.rg0 = r0;
                            return;
                        }
                    }
                    heapClassInst.heap8[r3 + r0] = (byte)r5;
                }
            }
        }
        commonVariable.rg0 = r0;
        return;
    }

    public  void alert(String message) {}


    public static void tlsfMalloc(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = (r0 + -1) | 0;
        if (uint(r2) < uint(numDefine41823)) {
            r0 = (r0 + numDefine7) | 0;
            r0 = r0 & numDefineNeg8;
            r2 = numDefine12;
            r0 = uint(r0) < uint(r2) ? r2 : r0;
        } else {
            r0 = 0;
        }
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r0;
        blockLocateFree(i7);
        r2 = commonVariable.rg0;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r0;
        r0 = sCurrentMemory;
        blockPrepareUsed(i7);
        r1 = commonVariable.rg0;
        r2 = r2 >> numDefine2;
        r0 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + 1];
        r3 = heapClassInst.heap32[r0];
        r2 = r2 & numDefineNeg4;
        r2 = (r3 + r2) | 0;
        r3 = sMaxMemory;
        r3 = r3 >> numDefine2;
        heapClassInst.heap32[r0] = r2;
        r0 = heapClassInst.heap32[r3];
        if (!(uint(r2) <= uint(r0))) {
            heapClassInst.heap32[r3] = r2;
        }
        commonVariable.rg0 = r1;
        return;
    }

    public static void blockLocateFree(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        repeat1: do {
            if (!(r0 == 0)) {
                r1 = heapClassInst.heap32[fp];
                if (uint(r0) > uint(numDefine31)) {
                    r2 = r0 >>> 1;
                    r2 = r0 | r2;
                    r3 = r2 >>> numDefine2;
                    r2 = r2 | r3;
                    r3 = r2 >>> numDefine4;
                    r2 = r2 | r3;
                    r3 = r2 >>> numDefine8;
                    r2 = r2 | r3;
                    r3 = r2 >>> numDefine16;
                    r2 = r2 | r3;
                    r3 = r2 ^ -1;
                    r4 = numDefine55765;
                    r3 = r3 >>> 1;
                    r2 = r4 & ~r2;
                    r3 = r3 & numDefine55765;
                    r2 = (r2 + r3) | 0;
                    r3 = r2 >>> numDefine2;
                    r2 = r2 & numDefine93459;
                    r3 = r3 & numDefine93459;
                    r2 = (r2 + r3) | 0;
                    r3 = r2 >>> numDefine4;
                    r2 = r2 & numDefine45135;
                    r3 = r3 & numDefine45135;
                    r2 = (r2 + r3) | 0;
                    r3 = r2 >>> numDefine8;
                    r2 = r2 & numDefine11935;
                    r3 = r3 & numDefine11935;
                    r2 = (r2 + r3) | 0;
                    r3 = r2 & numDefine65535;
                    r2 = r2 >>> numDefine16;
                    r5 = numDefine26;
                    r2 = (r3 + r2) | 0;
                    r3 = 1;
                    r2 = (r5 - r2) | 0;
                    r2 = r3 << r2;
                    r0 = (r0 + r2) | 0;
                    r0 = (r0 + -1) | 0;
                    if (uint(r0) > uint(numDefine255)) {
                        r2 = r0 >>> 1;
                        r2 = r0 | r2;
                        r3 = r2 >>> numDefine2;
                        r2 = r2 | r3;
                        r3 = r2 >>> numDefine4;
                        r2 = r2 | r3;
                        r3 = r2 >>> numDefine8;
                        r2 = r2 | r3;
                        r3 = r2 >>> numDefine16;
                        r2 = r2 | r3;
                        r3 = r2 ^ -1;
                        r3 = r3 >>> 1;
                        r4 = r4 & ~r2;
                        r2 = r3 & numDefine55765;
                        r4 = (r4 + r2) | 0;
                        r2 = r4 >>> numDefine2;
                        r4 = r4 & numDefine93459;
                        r2 = r2 & numDefine93459;
                        r4 = (r4 + r2) | 0;
                        r2 = r4 >>> numDefine4;
                        r4 = r4 & numDefine45135;
                        r2 = r2 & numDefine45135;
                        r4 = (r4 + r2) | 0;
                        r2 = r4 >>> numDefine8;
                        r4 = r4 & numDefine11935;
                        r2 = r2 & numDefine11935;
                        r4 = (r4 + r2) | 0;
                        r2 = r4 & numDefine65535;
                        r4 = r4 >>> numDefine16;
                        r4 = (r2 + r4) | 0;
                        r2 = (r5 - r4) | 0;
                        r0 = r0 >>> r2;
                        r2 = numDefine24;
                        r0 = r0 ^ numDefine32;
                        r4 = (r2 - r4) | 0;
                        label = numDefine5;
                    } else {
                        label = numDefine3;
                    }
                } else {
                    label = numDefine3;
                }
                if (label == numDefine3) {
                    r0 = r0 >>> numDefine3;
                    r4 = 0;
                }
                r2 = r4 << numDefine2;
                r2 = (r1 + r2) | 0;
                r2 = r2 >> numDefine2;
                r3 = -1;
                r2 = heapClassInst.heap32[r2 + 1];
                r0 = r3 << r0;
                r0 = r2 & r0;
                if (r0 == 0) {
                    r0 = r1 >> numDefine2;
                    r4 = (r4 + 1) | 0;
                    r0 = heapClassInst.heap32[r0];
                    r4 = r3 << r4;
                    r0 = r0 & r4;
                    if (r0 == 0) {
                        break repeat1;
                    } else {
                        r4 = (r0 + -1) | 0;
                        r0 = r4 & ~r0;
                        r4 = r0 >>> 1;
                        r0 = r0 & numDefine55765;
                        r4 = r4 & numDefine55765;
                        r0 = (r0 + r4) | 0;
                        r4 = r0 >>> numDefine2;
                        r0 = r0 & numDefine93459;
                        r4 = r4 & numDefine93459;
                        r0 = (r0 + r4) | 0;
                        r4 = r0 >>> numDefine4;
                        r0 = r0 & numDefine45135;
                        r4 = r4 & numDefine45135;
                        r0 = (r0 + r4) | 0;
                        r4 = r0 >>> numDefine8;
                        r0 = r0 & numDefine11935;
                        r4 = r4 & numDefine11935;
                        r0 = (r0 + r4) | 0;
                        r4 = r0 & numDefine65535;
                        r0 = r0 >>> numDefine16;
                        r4 = (r4 + r0) | 0;
                        r0 = r4 << numDefine2;
                        r0 = (r1 + r0) | 0;
                        r0 = r0 >> numDefine2;
                        r0 = heapClassInst.heap32[r0 + 1];
                    }
                }
                r2 = (r0 + -1) | 0;
                r2 = r2 & ~r0;
                r5 = r2 >>> 1;
                r2 = r2 & numDefine55765;
                r5 = r5 & numDefine55765;
                r2 = (r2 + r5) | 0;
                r5 = r2 >>> numDefine2;
                r2 = r2 & numDefine93459;
                r5 = r5 & numDefine93459;
                r2 = (r2 + r5) | 0;
                r5 = r2 >>> numDefine4;
                r2 = r2 & numDefine45135;
                r5 = r5 & numDefine45135;
                r2 = (r2 + r5) | 0;
                r5 = r2 >>> numDefine8;
                r2 = r2 & numDefine11935;
                r5 = r5 & numDefine11935;
                r2 = (r2 + r5) | 0;
                r5 = r2 & numDefine65535;
                r2 = r2 >>> numDefine16;
                r2 = (r5 + r2) | 0;
                r0 = r0 == 0 ? r3 : r2;
                r2 = r4 << numDefine7;
                r2 = (r1 + r2) | 0;
                r3 = r0 << numDefine2;
                r2 = (r2 + r3) | 0;
                r3 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine24];
                if (!(r3 == 0)) {
                    r2 = (r2 + numDefine96) | 0;
                    r5 = r3 >> numDefine2;
                    r6 = heapClassInst.heap32[r5 + numDefine2];
                    r5 = heapClassInst.heap32[r5 + numDefine3];
                    r7 = r6 >> numDefine2;
                    r8 = r5 >> numDefine2;
                    heapClassInst.heap32[r7 + numDefine3] = r5;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r8 + numDefine2] = r6;
                    r5 = heapClassInst.heap32[r2];
                    if (!(r5 != r3)) {
                        r5 = blockNull;
                        heapClassInst.heap32[r2] = r6;
                        if (!(r6 != r5)) {
                            r2 = r4 << numDefine2;
                            r2 = (r1 + r2) | 0;
                            r2 = r2 >> numDefine2;
                            r5 = 1;
                            r0 = r5 << r0;
                            r6 = heapClassInst.heap32[r2 + 1];
                            r0 = r6 & ~r0;
                            heapClassInst.heap32[r2 + 1] = r0;
                            if (!(r0 != 0)) {
                                r0 = r1 >> numDefine2;
                                r1 = r5 << r4;
                                r2 = heapClassInst.heap32[r0];
                                r1 = r2 & ~r1;
                                heapClassInst.heap32[r0] = r1;
                            }
                        }
                    }
                    commonVariable.rg0 = r3;
                    return;
                }
            }
        } while (false);
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
    }


    public static void  blockPrepareUsed(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        if (r0 == 0) {
            r0 = 0;
            commonVariable.rg0 = r0;
            return;
        } else {
            r1 = heapClassInst.heap32[fp + numDefine2];
            r2 = r0 >> numDefine2;
            r3 = heapClassInst.heap32[r2 + 1];
            r4 = r3 & numDefineNeg4;
            r5 = (r1 + numDefine16) | 0;
            if (uint(r4) >= uint(r5)) {
                r3 = heapClassInst.heap32[fp];
                r5 = (r0 + numDefine8) | 0;
                r6 = (r5 + r1) | 0;
                r7 = r6 >> numDefine2;
                r8 = numDefineNeg4;
                r9 = heapClassInst.heap32[r7];
                r8 = (r8 - r1) | 0;
                r9 = r9 & numDefine3;
                r4 = (r8 + r4) | 0;
                r4 = r9 | r4;
                heapClassInst.heap32[r7] = r4;
                r4 = heapClassInst.heap32[r2 + 1];
                r4 = r4 & numDefine3;
                r4 = r4 | r1;
                heapClassInst.heap32[r2 + 1] = r4;
                r4 = heapClassInst.heap32[r7];
                r4 = (r4 + numDefineNeg4) | 0;
                r8 = (r1 + numDefine4) | 0;
                r4 = r4 & numDefineNeg4;
                r1 = (r1 + numDefine8) | 0;
                r9 = (r4 + r8) | 0;
                r4 = (r4 + r1) | 0;
                r9 = (r5 + r9) | 0;
                r4 = (r5 + r4) | 0;
                r6 = (r6 + numDefineNeg4) | 0;
                r9 = r9 >> numDefine2;
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r9] = r6;
                r9 = heapClassInst.heap32[r4];
                r9 = r9 | numDefine2;
                heapClassInst.heap32[r4] = r9;
                r4 = heapClassInst.heap32[r7];
                r4 = r4 | 1;
                heapClassInst.heap32[r7] = r4;
                r4 = heapClassInst.heap32[r2 + 1];
                r4 = (r4 + numDefineNeg4) | 0;
                r4 = r4 & numDefineNeg4;
                r4 = (r5 + r4) | 0;
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r4] = r0;
                r4 = heapClassInst.heap32[r7];
                r9 = r4 & numDefineNeg4;
                r10 = r4 | numDefine2;
                heapClassInst.heap32[r7] = r10;
                if (uint(r9) > uint(numDefine255)) {
                    r4 = r9 >>> 1;
                    r4 = r9 | r4;
                    r7 = r4 >>> numDefine2;
                    r4 = r4 | r7;
                    r7 = r4 >>> numDefine4;
                    r4 = r4 | r7;
                    r7 = r4 >>> numDefine8;
                    r4 = r4 | r7;
                    r7 = r4 >>> numDefine16;
                    r4 = r4 | r7;
                    r7 = r4 ^ -1;
                    r10 = numDefine55765;
                    r7 = r7 >>> 1;
                    r4 = r10 & ~r4;
                    r7 = r7 & numDefine55765;
                    r4 = (r4 + r7) | 0;
                    r7 = r4 >>> numDefine2;
                    r4 = r4 & numDefine93459;
                    r7 = r7 & numDefine93459;
                    r4 = (r4 + r7) | 0;
                    r7 = r4 >>> numDefine4;
                    r4 = r4 & numDefine45135;
                    r7 = r7 & numDefine45135;
                    r4 = (r4 + r7) | 0;
                    r7 = r4 >>> numDefine8;
                    r4 = r4 & numDefine11935;
                    r7 = r7 & numDefine11935;
                    r4 = (r4 + r7) | 0;
                    r7 = r4 & numDefine65535;
                    r4 = r4 >>> numDefine16;
                    r10 = numDefine26;
                    r4 = (r7 + r4) | 0;
                    r7 = (r10 - r4) | 0;
                    r9 = r9 >>> r7;
                    r7 = numDefine24;
                    r9 = r9 ^ numDefine32;
                    r4 = (r7 - r4) | 0;
                } else {
                    r9 = r4 >>> numDefine3;
                    r4 = 0;
                }
                r7 = r4 << numDefine7;
                r7 = (r3 + r7) | 0;
                r10 = r9 << numDefine2;
                r7 = (r7 + r10) | 0;
                r7 = r7 >> numDefine2;
                r8 = (r5 + r8) | 0;
                r1 = (r5 + r1) | 0;
                r5 = heapClassInst.heap32[r7 + numDefine24];
                r8 = r8 >> numDefine2;
                r1 = r1 >> numDefine2;
                r10 = blockNull;
                heapClassInst.heap32[r8] = r5;
                r5 = r5 >> numDefine2;
                heapClassInst.heap32[r1] = r10;
                heapClassInst.heap32[r5 + numDefine3] = r6;
                r1 = 1;
                r5 = r3 >> numDefine2;
                heapClassInst.heap32[r7 + numDefine24] = r6;
                r6 = r4 << numDefine2;
                r4 = r1 << r4;
                r7 = heapClassInst.heap32[r5];
                r3 = (r3 + r6) | 0;
                r4 = r7 | r4;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r5] = r4;
                r1 = r1 << r9;
                r4 = heapClassInst.heap32[r3 + 1];
                r1 = r4 | r1;
                heapClassInst.heap32[r3 + 1] = r1;
                r3 = heapClassInst.heap32[r2 + 1];
            }
            r1 = r3 & numDefineNeg4;
            r0 = (r0 + numDefine8) | 0;
            r1 = (r0 + r1) | 0;
            r1 = r1 >> numDefine2;
            r3 = heapClassInst.heap32[r1];
            r3 = r3 & numDefineNeg3;
            heapClassInst.heap32[r1] = r3;
            r1 = heapClassInst.heap32[r2 + 1];
            r1 = r1 & numDefineNeg2;
            heapClassInst.heap32[r2 + 1] = r1;
            commonVariable.rg0 = r0;
            return;
        }
    }

    public static void assert1(boolean condition,String text){
        if (!condition) {
            String errorMessage = "Assertion failed: " + text;
        }
    }
    public static void assert1(boolean condition){
        if (!condition) {
            String errorMessage = "Assertion failed: ";
        }
    }


    public static int mallocInt(int bytes){
        if (heapClassInst.heap == null) {}
        int newOffset = CommonVariable.heapNewPos;
        commonVariable.heapNewPos += (bytes + numDefine3) & numDefine0xfffffffc;

        if (commonVariable.heapNewPos > mandreelTotalMemory) {
            assert1(false);
        }
        return newOffset;
    }

    public static void strcpy(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r1 ^ r0;
        r2 = r2 & numDefine3;
        repeat1: do {
            if (r2 == 0) {
                r2 = r0 & numDefine3;
                if (r2 != 0) {
                    r2 = r0 | numDefineNeg4;
                    repeat5: while (true) {
                        if (r2 != 0) {
                            r3 = heapClassInst.heapU8[r1];
                            r4 = (r0 + 1) | 0;
                            r1 = (r1 + 1) | 0;
                            r2 = (r2 + 1) | 0;
                            heapClassInst.heap8[r0] = (byte)r3;
                            r0 = r4;
                            if (!(r3 != 0)) {
                                break repeat1;
                            }
                        } else {
                            break repeat5;
                        }
                    }
                }
                r2 = r1 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r3 = (int) (r2 & numDefineNeg62144);
                r3 = (int) (r3 ^ numDefineNeg62144);
                r4 = (int) ((r2 + numDefineNeg43009) | 0);
                r3 = r3 & r4;
                repeat9: do {
                    if (r3 == 0) {
                        r1 = (r1 + numDefine4) | 0;
                        while (true) {
                            r3 = r0 >> numDefine2;
                            r4 = r1 >> numDefine2;
                            heapClassInst.heap32[r3] = r2;
                            r2 = heapClassInst.heap32[r4];
                            r3 = (int) (r2 & numDefineNeg62144);
                            r0 = (r0 + numDefine4) | 0;
                            r1 = (r1 + numDefine4) | 0;
                            r3 = (int) (r3 ^ numDefineNeg62144);
                            r4 = (int) ((r2 + numDefineNeg43009) | 0);
                            r3 = r3 & r4;
                            if (!(r3 == 0)) {
                                break repeat9;
                            }
                        }
                    }
                } while (false);
                r1 = r2 & numDefine255;
                heapClassInst.heap8[r0] = (byte)r2;
                if (!(r1 == 0)) {
                    r0 = (r0 + 1) | 0;
                    repeat15: while (true) {
                        r2 = r2 >>> numDefine8;
                        r1 = (r0 + 1) | 0;
                        heapClassInst.heap8[r0] = (byte)r2;
                        r3 = r2 & numDefine255;
                        r0 = r1;
                        if (r3 == 0) {
                            break repeat1;
                        } else {
                            continue repeat15;
                        }
                    }
                }
            } else {
                repeat17: while (true) {
                    r2 = heapClassInst.heapU8[r1];
                    r3 = (r0 + 1) | 0;
                    r1 = (r1 + 1) | 0;
                    heapClassInst.heap8[r0] = (byte)r2;
                    r0 = r3;
                    if (r2 == 0) {
                        break repeat1;
                    } else {
                        continue repeat17;
                    }
                }
            }
        } while (false);
        return;
    }

    public static void mallocNew(int sp) {
        sp = sp;
        int size = heapClassInst.heapU32[sp >> numDefine2];

        if (size == 0) {
            size = numDefine4;
        }

        if (tlsfPtr1.tlsfPtr == 0) {
            int addr = mallocInt(mandreelHeapMemory);

            sp -= numDefine8;
            heapClassInst.heap32[sp >> numDefine2] = addr;
            heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = mandreelHeapMemory;
            tlsfCreate(sp);
            tlsfPtr1.tlsfPtr = commonVariable.rg0;
        }

        sp -= numDefine8;

        heapClassInst.heap32[sp >> numDefine2] = tlsfPtr1.tlsfPtr;
        heapClassInst.heap32[(sp + numDefine4) >> numDefine2] = size;
        tlsfMalloc(sp);

        if (commonVariable.rg0 == 0) {
            dump("mallocNew failed " + size + '\n');
            assert1(false);
        }
    }


    public static void myArgTest(int sp){
        int ptr = heapClassInst.heapU32[sp >> numDefine2];
        int size = heapClassInst.heapU32[(sp + numDefine4) >> numDefine2];

        int arg = heapClassInst.heapU32[ptr >> numDefine2];

        if (size == numDefine4) {
            heapClassInst.heap32[ptr >> numDefine2] = arg + numDefine4;

            arg = heapClassInst.heap32[arg >> numDefine2];

            heapClassInst.heap32[argTestLocal >> numDefine2] = arg;
        } else {
            arg = (arg + numDefine7) & ~7;

            heapClassInst.heap32[ptr >> numDefine2] = arg + numDefine8;

            int value0 = heapClassInst.heap32[arg >> numDefine2];
            int value1 = heapClassInst.heap32[(arg + numDefine4) >> numDefine2];

            heapClassInst.heap32[argTestLocal >> numDefine2] = value0;
            heapClassInst.heap32[(argTestLocal + numDefine4) >> numDefine2] = value1;
        }
        commonVariable.rg0 = argTestLocal;
    }


    public static double llvmReadDouble(int addr){
        int val0 = heapClassInst.heap32[addr >> numDefine2];
        int val1 = heapClassInst.heap32[(addr + numDefine4) >> numDefine2];

        heapClassInst.heap32[llvmDoubleAddr >> numDefine2] = val0;
        heapClassInst.heap32[(llvmDoubleAddr + numDefine4) >> numDefine2] = val1;

        double result = heapClassInst.heapDouble[llvmDoubleAddr >> numDefine3];

        return result;
    }


    public static void llvmMoveDouble(int addrDst,int addrSrc) {
        int val0 = heapClassInst.heapU32[addrSrc >> numDefine2];
        int val1 = heapClassInst.heapU32[(addrSrc + numDefine4) >> numDefine2];

        heapClassInst.heapU32[addrDst >> numDefine2] = val0;
        heapClassInst.heapU32[(addrDst + numDefine4) >> numDefine2] = val1;
    }


    public static void dtostr(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        f0 = llvmReadDouble(sp);
        r0 = sp + numDefineNeg8;
        llvmWriteDouble(sp + numDefineNeg8, (int) f0);
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + 1];
        r1 = heapClassInst.heap32[fp + numDefine2];
        r2 = heapClassInst.heap32[fp + numDefine3];
        r3 = heapClassInst.heap32[fp + numDefine4];
        r4 = heapClassInst.heap32[fp + numDefine5];
        r5 = heapClassInst.heap32[fp + numDefine6];
        r6 = heapClassInst.heap32[fp + numDefineNeg2];
        if (r0 > numDefine35071) {
            r7 = (int) (r0 ^ numDefine59360);
            r7 = r6 | r7;
            if (r7 == 0) {
                label = numDefine13;
            } else {
                r7 = (int) (r0 ^ numDefine35072);
                r6 = r6 | r7;
                if (r6 != 0) {
                    label = numDefine20;
                } else {
                    label = numDefine5;
                }
            }
        } else {
            r7 = (int) (r0 ^ numDefineNeg48576);
            r7 = r6 | r7;
            if (r7 == 0) {
                label = numDefine5;
            } else {
                r7 = (int) (r0 ^ numDefineNeg24288);
                r6 = r6 | r7;
                if (r6 == 0) {
                    label = numDefine13;
                } else {
                    label = numDefine20;
                }
            }
        }
        repeat6: do {
            switch (label) {
                case numDefine13:
                    if (r2 > 0) {
                        r0 = (r2 + -1) | 0;
                        r3 = numDefine2;
                        r4 = 0;
                        r5 = (r2 + numDefine2) | 0;
                        r0 = uint(r0) > uint(r3) ? r0 : r3;
                        r3 = (r4 - r2) | 0;
                        r0 = (r5 - r0) | 0;
                        r4 = twoEStr9655;
                        r5 = r1;
                        repeat10: while (true) {
                            r6 = heapClassInst.heapU8[r4];
                            r0 = (r0 + -1) | 0;
                            r7 = (r5 + 1) | 0;
                            r4 = (r4 + 1) | 0;
                            heapClassInst.heap8[r5] = (byte)r6;
                            r5 = r7;
                            if (!(r0 != 0)) {
                                break repeat10;
                            }
                        }
                        r0 = numDefineNeg3;
                        r4 = numDefine3;
                        r0 = uint(r3) > uint(r0) ? r2 : r4;
                    } else {
                        r0 = 0;
                    }
                    if (r0 >= r2) {
                        commonVariable.rg0 = r0;
                        return;
                    } else {
                        label = numDefine11;
                        break repeat6;
                    }
                case numDefine20:
                    f1 = 0;
                    if (f0 != f1) {
                        r0 = r0 >>> numDefine20;
                        r0 = r0 & numDefine2047;
                        r0 = (r0 + numDefineNeg1023) | 0;
                        f2 = r0;
                        f3 = numDefineFloat312;
                        f2 = f2 * f3;
                        r0 = (int) f2 | 0;
                        r6 = (r0 + 1) | 0;
                        if (f0 < f1) {
                            f1 = -f0;
                            r2 = (r2 + -1) | 0;
                            r7 = (r1 + 1) | 0;
                            r8 = numDefine45;
                            heapClassInst.heap8[r1] = (byte)r8;
                        } else {
                            r7 = r1;
                            f1 = f0;
                        }
                        repeat23: do {
                            if (r4 == 0) {
                                f2 = numDefineFloat05;
                            } else {
                                f2 = numDefineFloat05;
                                r8 = r4;
                                f3 = numDefineFloat101;
                                while (true) {
                                    r8 = (r8 + -1) | 0;
                                    f2 = f2 * f3;
                                    if (!(r8 != 0)) {
                                        break repeat23;
                                    }
                                }
                            }
                        } while (false);
                        f1 = f1 + f2;
                        f2 = 1;
                        if (f1 < f2) {
                            r2 = (r2 + -1) | 0;
                            r8 = (r7 + 1) | 0;
                            r9 = numDefine48;
                            heapClassInst.heap8[r7] = (byte)r9;
                            r7 = r8;
                        }
                        repeat32: do {
                            if (r6 > 0) {
                                repeat34: do {
                                    if (uint(r6) > uint(numDefine10)) {
                                        r0 = (r0 + 1) | 0;
                                        f2 = numDefine10;
                                        f3 = numDefineN10;
                                        while (true) {
                                            r0 = (r0 + numDefineNeg10) | 0;
                                            f2 = f2 * f3;
                                            if (!(uint(r0) > uint(numDefine10))) {
                                                break repeat34;
                                            }
                                        }
                                    } else {
                                        f2 = numDefine10;
                                        r0 = r6;
                                    }
                                } while (false);
                                if (uint(r0) > uint(1)) {
                                    r0 = (r0 + -1) | 0;
                                    f3 = numDefine10;
                                    repeat42: while (true) {
                                        r0 = (r0 + -1) | 0;
                                        f2 = f2 * f3;
                                        if (!(r0 != 0)) {
                                            break repeat42;
                                        }
                                    }
                                    r0 = 1;
                                } else {
                                    r0 = 1;
                                }
                                repeat46: while (true) {
                                    f3 = numDefineFloat902;
                                    if (f2 > f3) {
                                        f3 = f1 / f2;
                                        r8 = (int) f3 | 0;
                                        if (r0 == 0) {
                                            label = numDefine52;
                                        } else {
                                            r9 = r8 & numDefine255;
                                            if (r9 != 0) {
                                                label = numDefine52;
                                            } else {
                                                label = numDefine64;
                                            }
                                        }
                                        if (label == numDefine52) {
                                            r0 = (r8 + numDefine48) | 0;
                                            heapClassInst.heap8[r7] = (byte)r0;
                                            if (r2 != 0) {
                                                r0 = r8 << numDefine24;
                                                r0 = r0 >> numDefine24;
                                                f3 = r0;
                                                f3 = f3 * f2;
                                                r7 = (r7 + 1) | 0;
                                                f1 = f1 - f3;
                                                r2 = (r2 + -1) | 0;
                                                r0 = 0;
                                            } else {
                                                break repeat46;
                                            }
                                        }
                                        f3 = numDefine10;
                                        f2 = f2 / f3;
                                    } else {
                                        label = numDefine66;
                                        break repeat32;
                                    }
                                }
                                f0 = f0 / f2;
                                llvmWriteDouble(i7, (int) f0);
                                heapClassInst.heap32[g0 + numDefine2] = r1;
                                heapClassInst.heap32[g0 + numDefine3] = r2;
                                heapClassInst.heap32[g0 + numDefine4] = r3;
                                heapClassInst.heap32[g0 + numDefine5] = r4;
                                heapClassInst.heap32[g0 + numDefine6] = 0;
                                dtostr(i7);
                                r0 = commonVariable.rg0;
                                if (r0 == 0) {
                                    label = numDefine83;
                                } else {
                                    r3 = (r0 + r7) | 0;
                                    r7 = (r3 + 1) | 0;
                                    if (r2 != r0) {
                                        r3 = (r3 + numDefine2) | 0;
                                        r4 = numDefine101;
                                        heapClassInst.heap8[r7] = (byte)r4;
                                        r7 = r3;
                                    }
                                    r2 = (r2 + -1) | 0;
                                    r3 = (r2 - r0) | 0;
                                    repeat60: do {
                                        if (r6 < numDefine1000) {
                                            if (r6 < numDefine100) {
                                                if (r6 > numDefine9) {
                                                    label = numDefine90;
                                                    break repeat60;
                                                } else {
                                                    label = numDefine91;
                                                    break repeat60;
                                                }
                                            } else {
                                                label = numDefine87;
                                                break repeat60;
                                            }
                                        } else {
                                            if (r2 != r0) {
                                                r0 = (r6 / numDefine1000) | 0;
                                                r2 = (r7 + 1) | 0;
                                                r0 = (r0 + numDefine48) | 0;
                                                heapClassInst.heap8[r7] = (byte)r0;
                                                r7 = r2;
                                            }
                                            r3 = (r3 + -1) | 0;
                                            r6 = r6 % numDefine1000 | 0;
                                            label = numDefine87;
                                        }
                                    } while (false);
                                    if (label == numDefine87) {
                                        if (r3 != 0) {
                                            r0 = (r6 / numDefine100) | 0;
                                            r2 = (r7 + 1) | 0;
                                            r0 = (r0 + numDefine48) | 0;
                                            heapClassInst.heap8[r7] = (byte)r0;
                                            r7 = r2;
                                        }
                                        r3 = (r3 + -1) | 0;
                                        r6 = r6 % numDefine100 | 0;
                                        label = numDefine90;
                                    }
                                    if (label == numDefine90) {
                                        if (r3 != 0) {
                                            r0 = (r6 / numDefine10) | 0;
                                            r2 = (r7 + 1) | 0;
                                            r0 = (r0 + numDefine48) | 0;
                                            heapClassInst.heap8[r7] = (byte)r0;
                                            r7 = r2;
                                        }
                                        r3 = (r3 + -1) | 0;
                                        r6 = r6 % numDefine10 | 0;
                                    }
                                    if (r3 != 0) {
                                        r0 = (r6 + numDefine48) | 0;
                                        heapClassInst.heap8[r7] = (byte)r0;
                                        if (r3 == 1) {
                                            label = numDefine83;
                                        } else {
                                            r7 = (r7 + 1) | 0;
                                            label = numDefine82;
                                        }
                                    } else {
                                        label = numDefine82;
                                    }
                                }
                            } else {
                                f2 = numDefineFloat101;
                                label = numDefine66;
                            }
                        } while (false);
                        repeat81: do {
                            if (label == numDefine66) {
                                if (r7 == r1) {
                                    if (r2 == 0) {
                                        label = numDefine83;
                                        break repeat81;
                                    } else {
                                        r2 = (r2 + -1) | 0;
                                        r6 = (r7 + 1) | 0;
                                        r0 = numDefine48;
                                        heapClassInst.heap8[r7] = (byte)r0;
                                        r7 = r6;
                                    }
                                }
                                if (!(r4 != 0)) {
                                    r6 = 1;
                                    r6 = (r6 - r1) | 0;
                                    r6 = (r6 + r7) | 0;
                                    if (!(uint(r6) < uint(r3))) {
                                        label = numDefine82;
                                        break repeat81;
                                    }
                                }
                                if (r2 == 0) {
                                    label = numDefine83;
                                } else {
                                    r6 = (r2 + -1) | 0;
                                    r0 = (r7 + 1) | 0;
                                    r2 = numDefine46;
                                    heapClassInst.heap8[r7] = (byte)r2;
                                    if (r5 == 0) {
                                        if (!(r4 != 0)) {
                                            r3 = (r1 + r3) | 0;
                                            r3 = (r3 + 1) | 0;
                                            r4 = (r3 - r0) | 0;
                                        }
                                    } else {
                                        r3 = r4 == 0 ? r3 : r4;
                                        r3 = (r1 + r3) | 0;
                                        r3 = (r3 + 1) | 0;
                                        r4 = (r3 - r0) | 0;
                                    }
                                    if (uint(r4) > uint(r6)) {
                                        label = numDefine83;
                                    } else {
                                        if (r4 != 0) {
                                            r3 = (r4 + 1) | 0;
                                            r6 = (r7 + 1) | 0;
                                            f3 = numDefine10;
                                            repeat99: while (true) {
                                                f0 = f1 / f2;
                                                r0 = (int) f0 | 0;
                                                r2 = r0 << numDefine24;
                                                r2 = r2 >> numDefine24;
                                                f0 = r2;
                                                f0 = f0 * f2;
                                                r4 = (r4 + -1) | 0;
                                                f2 = f2 / f3;
                                                f1 = f1 - f0;
                                                r2 = (r6 + 1) | 0;
                                                r0 = (r0 + numDefine48) | 0;
                                                heapClassInst.heap8[r6] = (byte)r0;
                                                r6 = r2;
                                                if (!(r4 != 0)) {
                                                    break repeat99;
                                                }
                                            }
                                            r7 = (r7 + r3) | 0;
                                            label = numDefine82;
                                        } else {
                                            r7 = r0;
                                            label = numDefine82;
                                        }
                                    }
                                }
                            }
                        } while (false);
                        switch (label) {
                            case numDefine83:
                                r1 = 0;
                                commonVariable.rg0 = r1;
                                return;
                            case numDefine82:
                                r3 = 0;
                                heapClassInst.heap8[r7] = (byte)r3;
                                r1 = (r7 - r1) | 0;
                                commonVariable.rg0 = r1;
                                return;
                            default:
                                break;
                        }
                    } else {
                        r3 = 1;
                        r5 = (r4 + numDefine2) | 0;
                        r4 = r4 == 0 ? r3 : r5;
                        r5 = numDefine8;
                        r2 = uint(r4) > uint(r2) ? r5 : r4;
                        if (r2 == 0) {
                            label = numDefine23;
                        } else {
                            if (r0 < 0) {
                                r0 = numDefine45;
                                heapClassInst.heap8[r1] = (byte)r0;
                                r0 = r3;
                                label = numDefine25;
                            } else {
                                label = numDefine23;
                            }
                        }
                        if (label == numDefine23) {
                            r0 = 0;
                        }
                        if (uint(r0) < uint(r2)) {
                            r5 = numDefine48;
                            repeat115: while (true) {
                                r4 = (r0 + 1) | 0;
                                heapClassInst.heap8[r1 + r0] = (byte)r5;
                                r0 = r4;
                                if (!(r2 != r4)) {
                                    break repeat115;
                                }
                            }
                            r0 = r2;
                        }
                        r2 = numDefine2;
                        r4 = heapClassInst.heapU8[r1];
                        r2 = r4 == numDefine48 ? r3 : r2;
                        r3 = numDefine46;
                        r4 = 0;
                        heapClassInst.heap8[r1 + r2] = (byte)r3;
                        heapClassInst.heap8[r1 + r0] = (byte)r4;
                        commonVariable.rg0 = r0;
                        return;
                    }
                    break;
                case numDefine5:
                    if (r2 > 0) {
                        r0 = (r2 + -1) | 0;
                        r3 = numDefine2;
                        r4 = 0;
                        r5 = (r2 + numDefine2) | 0;
                        r0 = uint(r0) > uint(r3) ? r0 : r3;
                        r3 = (r4 - r2) | 0;
                        r0 = (r5 - r0) | 0;
                        r4 = twoEStr7654;
                        r5 = r1;
                        repeat122: while (true) {
                            r6 = heapClassInst.heapU8[r4];
                            r0 = (r0 + -1) | 0;
                            r7 = (r5 + 1) | 0;
                            r4 = (r4 + 1) | 0;
                            heapClassInst.heap8[r5] = (byte)r6;
                            r5 = r7;
                            if (!(r0 != 0)) {
                                break repeat122;
                            }
                        }
                        r0 = numDefineNeg3;
                        r4 = numDefine3;
                        r0 = uint(r3) > uint(r0) ? r2 : r4;
                    } else {
                        r0 = 0;
                    }
                    if (r0 >= r2) {
                        label = numDefine12;
                    } else {
                        label = numDefine11;
                    }
                default:
                    break;
            }
        } while (false);
        if (label == numDefine11) {
            r2 = 0;
            heapClassInst.heap8[r1 + r0] = (byte)r2;
            r0 = (r0 + 1) | 0;
        }
        commonVariable.rg0 = r0;
        return;
    }


    public static void  swrite(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + 1];
        r2 = heapClassInst.heap32[r0 + numDefine2];
        r3 = heapClassInst.heap32[fp + 1];
        if (!(r2 == r1)) {
            r2 = (r2 - r1) | 0;
            r4 = heapClassInst.heap32[r0];
            r2 = uint(r2) < uint(r3) ? r2 : r3;
            if (r4 != 0) {
                r5 = heapClassInst.heap32[fp];
                r1 = (r4 + r1) | 0;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r5;
                heapClassInst.heap32[g0 + numDefine2] = r2;
                memcpy(i7);
                r1 = heapClassInst.heap32[r0 + 1];
                r4 = heapClassInst.heap32[r0];
                r1 = (r1 + r2) | 0;
                r5 = 0;
                heapClassInst.heap8[r4 + r1] = (byte)r5;
                r1 = heapClassInst.heap32[r0 + 1];
            }
            r1 = (r1 + r2) | 0;
            heapClassInst.heap32[r0 + 1] = r1;
        }
        commonVariable.rg0 = r3;
        
    }

//    public int registerDele(void ptrFunc(int sp)){}
//    function registerDelegate(ptrFunc: (number: number) => void): number {}
public static int registerDelegate(Consumer<Integer> ptrFunc) {
    int funcId = mandreelPosFunctionTable;
    functionTable.add((Consumer<Integer>) ptrFunc);

    mandreelPosFunctionTable += 1;
    deBugLog("funcId :" + funcId * numDefine4);
    return funcId * numDefine4;
}


    public static GetItemARR  mandreelGetlocalstorage() {
        return mandreelWindow.localStorage;
    }

    public static void sinf(int sp){
        float value = heapClassInst.heapFloat[sp >> numDefine2];
        commonVariable.fg0 = Math.sin(value);
    }

    public static void sqrtf(int sp){
        float value = heapClassInst.heapFloat[sp >> numDefine2];
        commonVariable.fg0 = Math.sqrt(value);
    }
    public static void assertNew(int sp) {
        sp = sp;
        int p0 = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int p1 = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        int line = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        String name = getStringFromPtr(p0);
        String file = getStringFromPtr(p1);
        assert1(false, name + file + ' ' + line);
    }

    public static void znwj(int sp){
        mallocNew(sp);
    }

    public static void  zdlPv(int sp){
        free(sp);
    }
    public  void   pause(int milliseconds) {}

    public static void acosf(int sp){
        float value = heapClassInst.heapFloat[sp >> numDefine2];
        commonVariable.fg0 = Math.acos(value);
    }

    public static void atan2f(int sp) {
        sp = sp;
        float x = heapClassInst.heapFloat[sp >> numDefine2];
        sp += numDefine4;
        float y = heapClassInst.heapFloat[sp >> numDefine2];
        commonVariable.fg0 = Math.atan2(x, y);
    }

    public static void zn20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvTIi(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = (r0 + r1) | 0;
        r3 = r2 >>> numDefine31;
        r4 = heapClassInst.heap32[fp];
        r2 = (r2 + r3) | 0;
        r3 = r4 >> numDefine2;
        r2 = (int) (r2 & numDefine70910);
        r5 = heapClassInst.heap32[r3 + numDefine3];
        r2 = r2 << numDefine3;
        r2 = (r5 + r2) | 0;
        r2 = r2 >> numDefine2;
        r5 = heapClassInst.heap32[r2];
        r6 = heapClassInst.heap32[r2 + 1];
        r2 = heapClassInst.heap32[r2 + numDefine2];
        r7 = r1;
        r8 = r0;
        repeat1: while (true) {
            r9 = heapClassInst.heap32[r3 + numDefine3];
            r10 = r7 << numDefine4;
            r10 = (r9 + r10) | 0;
            r11 = 0;
            repeat3: while (true) {
                r12 = r11 << numDefine4;
                r12 = (r10 + r12) | 0;
                r12 = r12 >> numDefine2;
                r13 = r11 << numDefine2;
                r14 = heapClassInst.heap32[r12];
                if (r14 != 0) {
                    r15 = r14 >> numDefine2;
                    r15 = heapClassInst.heap32[r15 + numDefine3];
                } else {
                    r15 = -1;
                }
                if (r5 != 0) {
                    r16 = r5 >> numDefine2;
                    r16 = heapClassInst.heap32[r16 + numDefine3];
                } else {
                    r16 = -1;
                }
                r17 = r13 << numDefine2;
                r17 = (r10 + r17) | 0;
                r17 = r17 >> numDefine2;
                r17 = heapClassInst.heap32[r17 + 1];
                if (r17 != 0) {
                    r18 = r17 >> numDefine2;
                    r18 = heapClassInst.heap32[r18 + numDefine3];
                } else {
                    r18 = -1;
                }
                if (r6 != 0) {
                    r19 = r6 >> numDefine2;
                    r19 = heapClassInst.heap32[r19 + numDefine3];
                } else {
                    r19 = -1;
                }
                repeat21: do {
                    if (!(r15 > r16)) {
                        if (!(r14 != r5)) {
                            if (r18 > r19) {
                                break repeat21;
                            }
                        }
                        if (r14 != r5) {
                            break repeat3;
                        } else {
                            if (r17 != r6) {
                                break repeat3;
                            } else {
                                r15 = r13 << numDefine2;
                                r15 = (r10 + r15) | 0;
                                r15 = r15 >> numDefine2;
                                r15 = heapClassInst.heap32[r15 + numDefine2];
                                if (!(uint(r15) > uint(r2))) {
                                    break repeat3;
                                }
                            }
                        }
                    }
                } while (false);
                r11 = (r11 + 1) | 0;
                continue repeat3;
            }
            r18 = r8 << numDefine4;
            r15 = (r7 + r11) | 0;
            r9 = (r9 + r18) | 0;
            r16 = 0;
            repeat30: while (true) {
                r19 = r16 << numDefine2;
                if (r5 != 0) {
                    r20 = r5 >> numDefine2;
                    r20 = heapClassInst.heap32[r20 + numDefine3];
                } else {
                    r20 = -1;
                }
                r21 = r19 << numDefine2;
                r21 = (r9 + r21) | 0;
                r21 = r21 >> numDefine2;
                r21 = heapClassInst.heap32[r21];
                if (r21 != 0) {
                    r22 = r21 >> numDefine2;
                    r22 = heapClassInst.heap32[r22 + numDefine3];
                } else {
                    r22 = -1;
                }
                if (r6 != 0) {
                    r23 = r6 >> numDefine2;
                    r23 = heapClassInst.heap32[r23 + numDefine3];
                } else {
                    r23 = -1;
                }
                r24 = r19 << numDefine2;
                r24 = (r9 + r24) | 0;
                r24 = r24 >> numDefine2;
                r24 = heapClassInst.heap32[r24 + 1];
                if (r24 != 0) {
                    r25 = r24 >> numDefine2;
                    r25 = heapClassInst.heap32[r25 + numDefine3];
                } else {
                    r25 = -1;
                }
                repeat48: do {
                    if (!(r20 > r22)) {
                        if (!(r5 != r21)) {
                            if (r23 > r25) {
                                break repeat48;
                            }
                        }
                        if (r5 != r21) {
                            break repeat30;
                        } else {
                            if (r6 != r24) {
                                break repeat30;
                            } else {
                                r20 = r19 << numDefine2;
                                r20 = (r9 + r20) | 0;
                                r20 = r20 >> numDefine2;
                                r20 = heapClassInst.heap32[r20 + numDefine2];
                                if (!(uint(r2) > uint(r20))) {
                                    break repeat30;
                                }
                            }
                        }
                    }
                } while (false);
                r16 = (r16 + -1) | 0;
                continue repeat30;
            }
            r20 = (r8 + r16) | 0;
            if (r15 <= r20) {
                r13 = r13 << numDefine2;
                r10 = (r10 + r13) | 0;
                r10 = r10 >> numDefine2;
                r13 = heapClassInst.heap32[r12 + numDefine3];
                r15 = heapClassInst.heap32[r10 + numDefine2];
                r19 = r19 << numDefine2;
                r19 = (r9 + r19) | 0;
                heapClassInst.heap32[r10] = r21;
                r20 = r16 << numDefine4;
                r19 = r19 >> numDefine2;
                heapClassInst.heap32[r10 + 1] = r24;
                r19 = heapClassInst.heap32[r19 + numDefine2];
                r9 = (r9 + r20) | 0;
                r9 = r9 >> numDefine2;
                heapClassInst.heap32[r10 + numDefine2] = r19;
                r9 = heapClassInst.heap32[r9 + numDefine3];
                heapClassInst.heap32[r12 + numDefine3] = r9;
                r9 = heapClassInst.heap32[r3 + numDefine3];
                r9 = (r9 + r18) | 0;
                r9 = (r9 + r20) | 0;
                r9 = r9 >> numDefine2;
                heapClassInst.heap32[r9] = r14;
                r7 = (r7 + r11) | 0;
                r8 = (r8 + r16) | 0;
                heapClassInst.heap32[r9 + 1] = r17;
                r7 = (r7 + 1) | 0;
                r8 = (r8 + -1) | 0;
                heapClassInst.heap32[r9 + numDefine2] = r15;
                heapClassInst.heap32[r9 + numDefine3] = r13;
            } else {
                r7 = r15;
                r8 = r20;
            }
            if (r7 <= r8) {
                continue repeat1;
            } else {
                break repeat1;
            }
        }
        if (!(r8 <= r1)) {
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r8;
            zn20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvTIi(i7);
        }
        if (!(r7 >= r0)) {
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r7;
            heapClassInst.heap32[g0 + numDefine2] = r0;
            zn20btAlignedObjectArrayI16btBroadphasePairE17quickSortInternalI29btBroadphasePairSortPredicateEEvTIi(i7);
        }
        return;
    }

    public static void zn20btAxisSweep3InternalItE11sortMaxDownEitP12btDispatcherb(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = r0 << numDefine2;
        r2 = (r1 + r2) | 0;
        r3 = heapClassInst.heap32[fp + numDefine2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine17];
        r4 = r3 << numDefine2;
        r5 = (r2 + r4) | 0;
        r4 = heapClassInst.heapU16[(r2 + r4) >> 1];
        r6 = heapClassInst.heapU16[(r5 + numDefineNeg4) >> 1];
        if (!(uint(r4) >= uint(r6))) {
            r1 = r1 >> numDefine2;
            r4 = heapClassInst.heap32[fp + numDefine3];
            r6 = heapClassInst.heap32[fp + numDefine4];
            r7 = heapClassInst.heap32[r1 + numDefine15];
            r3 = r3 << numDefine2;
            r2 = (r2 + r3) | 0;
            r2 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
            r3 = 1;
            r8 = r3 << r0;
            r2 = r2 << numDefine6;
            r8 = r8 & numDefine3;
            r2 = (r7 + r2) | 0;
            r0 = r0 << 1;
            r3 = r3 << r8;
            r2 = (r2 + r0) | 0;
            r3 = r3 & numDefine3;
            r2 = (r2 + numDefine54) | 0;
            r5 = (r5 + numDefine2) | 0;
            repeat3: while (true) {
                r9 = heapClassInst.heapU8[r5 + numDefineNeg6];
                r10 = heapClassInst.heapU16[(r5 + numDefineNeg4) >> 1];
                r9 = r9 & 1;
                if (r9 != 0) {
                    r9 = r10 << numDefine6;
                    r7 = (r7 + r9) | 0;
                    r7 = (r7 + r0) | 0;
                    r9 = heapClassInst.heapU16[(r7 + numDefine54) >> 1];
                    r9 = (r9 + 1) | 0;
                    heapClassInst.heap16[(r7 + numDefine54) >> 1] = (short)r9;
                } else {
                    if (!(r6 == 0)) {
                        r9 = heapClassInst.heapU16[r5 >> 1];
                        r9 = r9 << numDefine6;
                        r11 = r10 << numDefine6;
                        r9 = (r7 + r9) | 0;
                        r12 = r8 << 1;
                        r11 = (r7 + r11) | 0;
                        r13 = (r9 + r12) | 0;
                        r12 = (r11 + r12) | 0;
                        r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
                        r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
                        if (!(uint(r14) < uint(r15))) {
                            r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
                            r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
                            if (!(uint(r12) < uint(r13))) {
                                r12 = r3 << 1;
                                r13 = (r9 + r12) | 0;
                                r12 = (r11 + r12) | 0;
                                r14 = heapClassInst.heapU16[(r13 + numDefine54) >> 1];
                                r15 = heapClassInst.heapU16[(r12 + numDefine48) >> 1];
                                if (!(uint(r14) < uint(r15))) {
                                    r12 = heapClassInst.heapU16[(r12 + numDefine54) >> 1];
                                    r13 = heapClassInst.heapU16[(r13 + numDefine48) >> 1];
                                    if (!(uint(r12) < uint(r13))) {
                                        r12 = heapClassInst.heap32[r1 + numDefine23];
                                        r13 = r12 >> numDefine2;
                                        r13 = heapClassInst.heap32[r13];
                                        r13 = r13 >> numDefine2;
                                        r13 = heapClassInst.heap32[r13 + numDefine3];
                                        heapClassInst.heap32[g0] = r12;
                                        heapClassInst.heap32[g0 + 1] = r9;
                                        heapClassInst.heap32[g0 + numDefine2] = r11;
                                        heapClassInst.heap32[g0 + numDefine3] = r4;
                                        functionTable.get(r13 >> numDefine2).accept(i7);
                                        r12 = heapClassInst.heap32[r1 + numDefine24];
                                        if (!(r12 == 0)) {
                                            r13 = r12 >> numDefine2;
                                            r13 = heapClassInst.heap32[r13];
                                            r13 = r13 >> numDefine2;
                                            r13 = heapClassInst.heap32[r13 + numDefine3];
                                            heapClassInst.heap32[g0] = r12;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r11;
                                            heapClassInst.heap32[g0 + numDefine3] = r4;
                                            functionTable.get(r13 >> numDefine2).accept(i7);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    r10 = r10 << numDefine6;
                    r7 = (r7 + r10) | 0;
                    r7 = (r7 + r0) | 0;
                    r10 = heapClassInst.heapU16[(r7 + numDefine48) >> 1];
                    r10 = (r10 + 1) | 0;
                    heapClassInst.heap16[(r7 + numDefine48) >> 1] = (short)r10;
                }
                r7 = heapClassInst.heapU16[r2 >> 1];
                r7 = (r7 + -1) | 0;
                heapClassInst.heap16[r2 >> 1] = (short)r7;
                r7 = heapClassInst.heapU16[(r5 + numDefineNeg2) >> 1];
                r9 = heapClassInst.heapU16[r5 >> 1];
                r10 = heapClassInst.heapU16[(r5 + numDefineNeg4) >> 1];
                r11 = heapClassInst.heapU16[(r5 + numDefineNeg6) >> 1];
                heapClassInst.heap16[(r5 + numDefineNeg2) >> 1] = (short)r11;
                heapClassInst.heap16[r5 >> 1] = (short)r10;
                heapClassInst.heap16[(r5 + numDefineNeg6) >> 1] = (short)r7;
                heapClassInst.heap16[(r5 + numDefineNeg4) >> 1] = (short)r9;
                r9 = heapClassInst.heapU16[(r5 + numDefineNeg10) >> 1];
                if (uint(r7) >= uint(r9)) {
                    break repeat3;
                } else {
                    r7 = heapClassInst.heap32[r1 + numDefine15];
                    r5 = (r5 + numDefineNeg4) | 0;
                    continue repeat3;
                }
            }
        }
        return;
    }


    public static void zn20btAxisSweep3InternalItE11sortMinDownEitP12btDispatcherb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = r0 << numDefine2;
        r2 = (r1 + r2) | 0;
        r3 = heapClassInst.heap32[fp + numDefine2];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine17];
        r3 = r3 << numDefine2;
        r4 = (r2 + r3) | 0;
        r2 = heapClassInst.heapU16[(r2 + r3) >> 1];
        r3 = heapClassInst.heapU16[(r4 + numDefineNeg4) >> 1];
        if (!(uint(r2) >= uint(r3))) {
            r1 = r1 >> numDefine2;
            r2 = heapClassInst.heap32[fp + numDefine3];
            r3 = heapClassInst.heap32[r1 + numDefine15];
            r5 = heapClassInst.heapU16[(r4 + numDefine2) >> 1];
            r6 = 1;
            r7 = r6 << r0;
            r7 = r7 & numDefine3;
            r6 = r6 << r7;
            r5 = r5 << numDefine6;
            r5 = (r3 + r5) | 0;
            r6 = r6 & numDefine3;
            r0 = r0 << 1;
            r8 = (r5 + numDefine48) | 0;
            r7 = r7 << 1;
            r9 = (r5 + numDefine54) | 0;
            r6 = r6 << 1;
            r10 = (r8 + r0) | 0;
            r11 = (r9 + r7) | 0;
            r12 = (r8 + r7) | 0;
            r9 = (r9 + r6) | 0;
            r8 = (r8 + r6) | 0;
            r4 = (r4 + numDefine2) | 0;
            repeat3: while (true) {
                r13 = heapClassInst.heapU8[r4 + numDefineNeg6];
                r14 = heapClassInst.heapU16[(r4 + numDefineNeg4) >> 1];
                r13 = r13 & 1;
                if (r13 == 0) {
                    r13 = r14 << numDefine6;
                    r3 = (r3 + r13) | 0;
                    r3 = (r3 + r0) | 0;
                    r13 = heapClassInst.heapU16[(r3 + numDefine48) >> 1];
                    r13 = (r13 + 1) | 0;
                    heapClassInst.heap16[(r3 + numDefine48) >> 1] = (short)r13;
                } else {
                    if (!(r2 == 0)) {
                        r13 = r14 << numDefine6;
                        r13 = (r3 + r13) | 0;
                        r15 = (r13 + r7) | 0;
                        r16 = heapClassInst.heapU16[r11 >> 1];
                        r17 = heapClassInst.heapU16[(r15 + numDefine48) >> 1];
                        if (!(uint(r16) < uint(r17))) {
                            r15 = heapClassInst.heapU16[(r15 + numDefine54) >> 1];
                            r16 = heapClassInst.heapU16[r12 >> 1];
                            if (!(uint(r15) < uint(r16))) {
                                r15 = (r13 + r6) | 0;
                                r16 = heapClassInst.heapU16[r9 >> 1];
                                r17 = heapClassInst.heapU16[(r15 + numDefine48) >> 1];
                                if (!(uint(r16) < uint(r17))) {
                                    r15 = heapClassInst.heapU16[(r15 + numDefine54) >> 1];
                                    r16 = heapClassInst.heapU16[r8 >> 1];
                                    if (!(uint(r15) < uint(r16))) {
                                        r15 = heapClassInst.heap32[r1 + numDefine23];
                                        r16 = r15 >> numDefine2;
                                        r16 = heapClassInst.heap32[r16];
                                        r16 = r16 >> numDefine2;
                                        r16 = heapClassInst.heap32[r16 + numDefine2];
                                        heapClassInst.heap32[g0] = r15;
                                        heapClassInst.heap32[g0 + 1] = r5;
                                        heapClassInst.heap32[g0 + numDefine2] = r13;
                                        functionTable.get(r16 >> numDefine2).accept(i7);
                                        r15 = heapClassInst.heap32[r1 + numDefine24];
                                        if (!(r15 == 0)) {
                                            r16 = r15 >> numDefine2;
                                            r16 = heapClassInst.heap32[r16];
                                            r16 = r16 >> numDefine2;
                                            r16 = heapClassInst.heap32[r16 + numDefine2];
                                            heapClassInst.heap32[g0] = r15;
                                            heapClassInst.heap32[g0 + 1] = r5;
                                            heapClassInst.heap32[g0 + numDefine2] = r13;
                                            functionTable.get(r16 >> numDefine2).accept(i7);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    r14 = r14 << numDefine6;
                    r3 = (r3 + r14) | 0;
                    r3 = (r3 + r0) | 0;
                    r14 = heapClassInst.heapU16[(r3 + numDefine54) >> 1];
                    r14 = (r14 + 1) | 0;
                    heapClassInst.heap16[(r3 + numDefine54) >> 1] = (short)r14;
                }
                r3 = heapClassInst.heapU16[r10 >> 1];
                r3 = (r3 + -1) | 0;
                heapClassInst.heap16[r10 >> 1] = (short)r3;
                r3 = heapClassInst.heapU16[(r4 + numDefineNeg2) >> 1];
                r13 = heapClassInst.heapU16[r4 >> 1];
                r14 = heapClassInst.heapU16[(r4 + numDefineNeg4) >> 1];
                r15 = heapClassInst.heapU16[(r4 + numDefineNeg6) >> 1];
                heapClassInst.heap16[(r4 + numDefineNeg2) >> 1] = (short)r15;
                heapClassInst.heap16[r4 >> 1] = (short)r14;
                heapClassInst.heap16[(r4 + numDefineNeg6) >> 1] = (short)r3;
                heapClassInst.heap16[(r4 + numDefineNeg4) >> 1] = (short)r13;
                r13 = heapClassInst.heapU16[(r4 + numDefineNeg10) >> 1];
                if (uint(r3) >= uint(r13)) {
                    break repeat3;
                } else {
                    r3 = heapClassInst.heap32[r1 + numDefine15];
                    r4 = (r4 + numDefineNeg4) | 0;
                    continue repeat3;
                }
            }
        }
        return;
    }

    public static void  znk20btAxisSweep3InternalItE8quantizeEPtRK9btVector3i(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + numDefine2];
        f1 = heapClassInst.heapFloat[r1 + numDefine2];
        f2 = heapClassInst.heapFloat[fp + numDefine4];
        f3 = heapClassInst.heapFloat[r1 + numDefine4];
        f4 = heapClassInst.heapFloat[fp + numDefine3];
        f5 = heapClassInst.heapFloat[r1 + numDefine3];
        f0 = f0 - f1;
        f1 = heapClassInst.heapFloat[r1 + numDefine10];
        f2 = f2 - f3;
        f3 = heapClassInst.heapFloat[r1 + numDefine12];
        f4 = f4 - f5;
        f5 = heapClassInst.heapFloat[r1 + numDefine11];
        f0 = f0 * f1;
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine5];
        f1 = f2 * f3;
        f2 = f4 * f5;
        f3 = 0;
        if (f0 > f3) {
            r3 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            f4 = r3;
            if (f0 < f4) {
                r3 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                r4 = (int) Math.floor(f0);
                r3 = r3 & (int)r4;
                r3 = r3 | r2;
            } else {
                r4 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                r3 = (int)r4 & r3;
                r3 = r3 | r2;
            }
        } else {
            r3 = r2;
        }
        heapClassInst.heap16[r1 >> 1] = (short)r3;
        if (f2 > f3) {
            r3 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            f0 = r3;
            if (f2 < f0) {
                r3 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                r4 = (int) Math.floor(f2);
                r3 = r3 & (int)r4;
                r3 = r3 | r2;
            } else {
                r4 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                r3 = r4 & r3;
                r3 = r3 | r2;
            }
        } else {
            r3 = r2;
        }
        heapClassInst.heap16[(r1 + numDefine2) >> 1] = (short)r3;
        if (f1 > f3) {
            r3 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
            f0 = r3;
            if (f1 < f0) {
                r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                r3 = (int) Math.floor(f1);
                r0 = r0 & r3;
                r2 = r0 | r2;
            } else {
                r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                r0 = r0 & r3;
                r2 = r0 | r2;
            }
        }
        heapClassInst.heap16[(r1 + numDefine4) >> 1] = (short)r2;
        return;
    }

    public  void waMandreelAudioUpdate(int sp) {}

    public static void mandreelAudioIsLogEnabled(int sp) {
        commonVariable.rg0 = 0;
    }

    public static void  mandreelFlashSocketsGetFlashMovieObject(String movieName){}

    public static void  mandreelAudioGetAudioDriverName(int sp){
        sp = sp;
        int namePtr = heapClassInst.heap32[sp >> numDefine2];
        sp += numDefine4;
        fillPtrFromString(namePtr, commonVariable.mandreelAudioDriver);
    }

    public static void zn20btAlignedObjectArrayI18btQuantizedBvhNodeE7reserveEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r2 + numDefine2];
        if (!(r3 >= r1)) {
            if (r1 != 0) {
                r3 = gNumAlignedAllocs;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r5 = r1 << numDefine4;
                r4 = (r4 + 1) | 0;
                r5 = r5 | numDefine3;
                heapClassInst.heap32[r3] = r4;
                r3 = (r5 + numDefine16) | 0;
                heapClassInst.heap32[g0] = r3;
                mallocNew(i7);
                r3 = commonVariable.rg0;
                if (r3 != 0) {
                    r4 = 0;
                    r5 = (r3 + numDefine4) | 0;
                    r4 = (r4 - r5) | 0;
                    r4 = r4 & numDefine15;
                    r4 = (r3 + r4) | 0;
                    r5 = (r4 + numDefine4) | 0;
                    r4 = r4 >> numDefine2;
                    heapClassInst.heap32[r4] = r3;
                    r3 = r5;
                }
            } else {
                r3 = 0;
            }
            r4 = heapClassInst.heap32[r2 + 1];
            r5 = (r0 + numDefine12) | 0;
            if (r4 < 1) {
                r4 = r5 >> numDefine2;
                r7 = heapClassInst.heap32[r4];
            } else {
                r6 = 0;
                repeat11: while (true) {
                    r7 = r5 >> numDefine2;
                    r7 = heapClassInst.heap32[r7];
                    r8 = r6 << numDefine4;
                    r9 = heapClassInst.heapU16[(r7 + r8) >> 1];
                    r10 = (r7 + r8) | 0;
                    heapClassInst.heap16[(r3 + r8) >> 1] = (short)r9;
                    r8 = (r3 + r8) | 0;
                    r9 = heapClassInst.heapU16[(r10 + numDefine2) >> 1];
                    heapClassInst.heap16[(r8 + numDefine2) >> 1] = (short)r9;
                    r9 = heapClassInst.heapU16[(r10 + numDefine4) >> 1];
                    heapClassInst.heap16[(r8 + numDefine4) >> 1] = (short)r9;
                    r9 = heapClassInst.heapU16[(r10 + numDefine6) >> 1];
                    heapClassInst.heap16[(r8 + numDefine6) >> 1] = (short)r9;
                    r9 = heapClassInst.heapU16[(r10 + numDefine8) >> 1];
                    heapClassInst.heap16[(r8 + numDefine8) >> 1] = (short)r9;
                    r9 = heapClassInst.heapU16[(r10 + numDefine10) >> 1];
                    r10 = r10 >> numDefine2;
                    heapClassInst.heap16[(r8 + numDefine10) >> 1] = (short)r9;
                    r6 = (r6 + 1) | 0;
                    r8 = r8 >> numDefine2;
                    r9 = heapClassInst.heap32[r10 + numDefine3];
                    heapClassInst.heap32[r8 + numDefine3] = r9;
                    if (!(r4 != r6)) {
                        break repeat11;
                    }
                }
                r5 = (r0 + numDefine12) | 0;
            }
            if (!(r7 == 0)) {
                r4 = heapClassInst.heapU8[r0 + numDefine16];
                if (!(r4 == 0)) {
                    r4 = gNumAlignedFree;
                    r4 = r4 >> numDefine2;
                    r6 = heapClassInst.heap32[r4];
                    r6 = (r6 + 1) | 0;
                    r7 = r7 >> numDefine2;
                    heapClassInst.heap32[r4] = r6;
                    r4 = heapClassInst.heap32[r7 + -1];
                    heapClassInst.heap32[g0] = r4;
                    free(i7);
                }
                r4 = r5 >> numDefine2;
                heapClassInst.heap32[r4] = 0;
            }
            r4 = 1;
            r5 = r5 >> numDefine2;
            heapClassInst.heap8[r0 + numDefine16] = (byte)r4;
            heapClassInst.heap32[r5] = r3;
            heapClassInst.heap32[r2 + numDefine2] = r1;
        }
        return;
    }


    public static void znk14btQuantizedBvh8quantizeEPtRK9btVector3i(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine60];
        if (r1 != 0) {
            r1 = heapClassInst.heap32[fp + numDefine2];
            r1 = r1 >> numDefine2;
            f0 = heapClassInst.heapFloat[r1];
            r0 = r0 >> numDefine2;
            f1 = heapClassInst.heapFloat[r0 + numDefine5];
            if (f0 <= f1) {
                f1 = heapClassInst.heapFloat[r1 + 1];
                f2 = heapClassInst.heapFloat[r0 + numDefine6];
                if (f1 <= f2) {
                    f2 = heapClassInst.heapFloat[r1 + numDefine2];
                    f3 = heapClassInst.heapFloat[r0 + numDefine7];
                    if (f2 <= f3) {
                        f3 = heapClassInst.heapFloat[r0 + 1];
                        if (f0 >= f3) {
                            f4 = heapClassInst.heapFloat[r0 + numDefine2];
                            if (f1 >= f4) {
                                f5 = heapClassInst.heapFloat[r0 + numDefine3];
                                if (f2 >= f5) {
                                    r1 = heapClassInst.heap32[fp + 1];
                                    r2 = heapClassInst.heap32[fp + numDefine3];
                                    f2 = f2 - f5;
                                    f5 = heapClassInst.heapFloat[r0 + numDefine11];
                                    f1 = f1 - f4;
                                    f4 = heapClassInst.heapFloat[r0 + numDefine10];
                                    f0 = f0 - f3;
                                    f3 = heapClassInst.heapFloat[r0 + numDefine9];
                                    f2 = f2 * f5;
                                    f1 = f1 * f4;
                                    f0 = f0 * f3;
                                    if (r2 == 0) {
                                        r0 = (int) Math.floor(f0);
                                        r2 = (int) Math.floor(f1);
                                        r0 = r0 & numDefine65534;
                                        r3 = (int) Math.floor(f2);
                                        r2 = r2 & numDefine65534;
                                        heapClassInst.heap16[r1 >> 1] = (short)r0;
                                        r0 = r3 & numDefine65534;
                                    } else {
                                        f3 = 1;
                                        f0 = f0 + f3;
                                        f1 = f1 + f3;
                                        r0 = (int) Math.floor(f0);
                                        f0 = f2 + f3;
                                        r2 = (int)Math.floor(f1);
                                        r0 = r0 | 1;
                                        r3 = (int)Math.floor(f0);
                                        r2 = r2 | 1;
                                        heapClassInst.heap16[r1 >> 1] = (short)r0;
                                        r0 = r3 | 1;
                                    }
                                    heapClassInst.heap16[(r1 + numDefine2) >> 1] = (short)r2;
                                    heapClassInst.heap16[(r1 + numDefine4) >> 1] = (short)r0;
                                    return;
                                } else {
                                    r0 = twoEStr9;
                                    r1 = twoEStr313;
                                    heapClassInst.heap32[g0] = r0;
                                    heapClassInst.heap32[g0 + 1] = r1;
                                    heapClassInst.heap32[g0 + numDefine2] = numDefine361;
                                    assertNew(i7);
                                }
                            } else {
                                r0 = twoEStr820;
                                r1 = twoEStr313;
                                heapClassInst.heap32[g0] = r0;
                                heapClassInst.heap32[g0 + 1] = r1;
                                heapClassInst.heap32[g0 + numDefine2] = numDefine360;
                                assertNew(i7);
                            }
                        } else {
                            r0 = twoEStr717;
                            r1 = twoEStr313;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine359;
                            assertNew(i7);
                        }
                    } else {
                        r0 = twoEStr616;
                        r1 = twoEStr313;
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r1;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine357;
                        assertNew(i7);
                    }
                } else {
                    r0 = twoEStr515;
                    r1 = twoEStr313;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine356;
                    assertNew(i7);
                }
            } else {
                r0 = twoEStr414;
                r1 = twoEStr313;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine355;
                assertNew(i7);
            }
        } else {
            r0 = twoEStr212;
            r1 = twoEStr313;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine353;
            assertNew(i7);
        }
    }

    public static void zn6btDbvt9collideTVEPK10btDbvtNodeRK12btDbvtAabbMmRNS8ICollideE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        if (!(r0 == 0)) {
            r1 = heapClassInst.heap32[fp + 1];
            r2 = heapClassInst.heap32[fp + numDefine2];
            r3 = gNumAlignedAllocs;
            r1 = r1 >> numDefine2;
            r3 = r3 >> numDefine2;
            r4 = heapClassInst.heap32[r3];
            f0 = heapClassInst.heapFloat[r1];
            f1 = heapClassInst.heapFloat[r1 + 1];
            f2 = heapClassInst.heapFloat[r1 + numDefine2];
            f3 = heapClassInst.heapFloat[r1 + numDefine4];
            f4 = heapClassInst.heapFloat[r1 + numDefine5];
            f5 = heapClassInst.heapFloat[r1 + numDefine6];
            r1 = (r4 + 1) | 0;
            heapClassInst.heap32[r3] = r1;
            heapClassInst.heap32[g0] = numDefine275;
            mallocNew(i7);
            r1 = commonVariable.rg0;
            if (r1 != 0) {
                r4 = 0;
                r5 = (r1 + numDefine4) | 0;
                r4 = (r4 - r5) | 0;
                r4 = r4 & numDefine15;
                r4 = (r1 + r4) | 0;
                r5 = (r4 + numDefine4) | 0;
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r4] = r1;
                r1 = r5;
            }
            r4 = 1;
            r5 = numDefine64;
            r6 = r1 >> numDefine2;
            heapClassInst.heap32[r6] = r0;
            repeat6: while (true) {
                r0 = r4;
                r4 = (r0 + -1) | 0;
                r6 = r4 << numDefine2;
                r6 = (r1 + r6) | 0;
                r6 = r6 >> numDefine2;
                r6 = heapClassInst.heap32[r6];
                r7 = r6 >> numDefine2;
                f6 = heapClassInst.heapFloat[r7];
                if (f6 <= f3) {
                    f6 = heapClassInst.heapFloat[r7 + numDefine4];
                    if (!(f6 < f0)) {
                        f6 = heapClassInst.heapFloat[r7 + 1];
                        if (!(f6 > f4)) {
                            f6 = heapClassInst.heapFloat[r7 + numDefine5];
                            if (!(f6 < f1)) {
                                f6 = heapClassInst.heapFloat[r7 + numDefine2];
                                if (!(f6 > f5)) {
                                    f6 = heapClassInst.heapFloat[r7 + numDefine6];
                                    if (!(f6 < f2)) {
                                        r8 = heapClassInst.heap32[r7 + numDefine10];
                                        if (r8 == 0) {
                                            r0 = r2 >> numDefine2;
                                            r0 = heapClassInst.heap32[r0];
                                            r0 = r0 >> numDefine2;
                                            r0 = heapClassInst.heap32[r0 + numDefine3];
                                            heapClassInst.heap32[g0] = r2;
                                            heapClassInst.heap32[g0 + 1] = r6;
                                            functionTable.get(r0 >> numDefine2).accept(i7);
                                        } else {
                                            r6 = heapClassInst.heap32[r7 + numDefine9];
                                            if (r5 == r4) {
                                                r8 = 1;
                                                r9 = r4 << 1;
                                                r8 = r4 == 0 ? r8 : r9;
                                                if (!(r5 >= r8)) {
                                                    if (r8 != 0) {
                                                        r5 = heapClassInst.heap32[r3];
                                                        r9 = r8 << numDefine2;
                                                        r5 = (r5 + 1) | 0;
                                                        r9 = r9 | numDefine3;
                                                        heapClassInst.heap32[r3] = r5;
                                                        r5 = (r9 + numDefine16) | 0;
                                                        heapClassInst.heap32[g0] = r5;
                                                        mallocNew(i7);
                                                        r9 = commonVariable.rg0;
                                                        if (r9 != 0) {
                                                            r5 = 0;
                                                            r10 = (r9 + numDefine4) | 0;
                                                            r5 = (r5 - r10) | 0;
                                                            r5 = r5 & numDefine15;
                                                            r5 = (r9 + r5) | 0;
                                                            r10 = (r5 + numDefine4) | 0;
                                                            r5 = r5 >> numDefine2;
                                                            heapClassInst.heap32[r5] = r9;
                                                            r9 = r10;
                                                        }
                                                    } else {
                                                        r9 = 0;
                                                    }
                                                    if (!(r4 < 1)) {
                                                        r4 = (r0 + -1) | 0;
                                                        r5 = r1;
                                                        r10 = r9;
                                                        repeat28: while (true) {
                                                            r11 = r5 >> numDefine2;
                                                            r4 = (r4 + -1) | 0;
                                                            r12 = (r10 + numDefine4) | 0;
                                                            r5 = (r5 + numDefine4) | 0;
                                                            r10 = r10 >> numDefine2;
                                                            r11 = heapClassInst.heap32[r11];
                                                            heapClassInst.heap32[r10] = r11;
                                                            r10 = r12;
                                                            if (!(r4 != 0)) {
                                                                break repeat28;
                                                            }
                                                        }
                                                    }
                                                    if (r1 != 0) {
                                                        r4 = gNumAlignedFree;
                                                        r4 = r4 >> numDefine2;
                                                        r5 = heapClassInst.heap32[r4];
                                                        r5 = (r5 + 1) | 0;
                                                        r1 = r1 >> numDefine2;
                                                        heapClassInst.heap32[r4] = r5;
                                                        r1 = heapClassInst.heap32[r1 + -1];
                                                        heapClassInst.heap32[g0] = r1;
                                                        free(i7);
                                                        r5 = r8;
                                                        r1 = r9;
                                                    } else {
                                                        r5 = r8;
                                                        r1 = r9;
                                                    }
                                                }
                                            }
                                            r4 = r0 << numDefine2;
                                            r8 = (r1 + r4) | 0;
                                            r8 = r8 >> numDefine2;
                                            heapClassInst.heap32[r8 + -1] = r6;
                                            r6 = heapClassInst.heap32[r7 + numDefine10];
                                            if (r5 == r0) {
                                                r7 = 1;
                                                r8 = r0 << 1;
                                                r7 = r0 == 0 ? r7 : r8;
                                                if (!(r5 >= r7)) {
                                                    if (r7 != 0) {
                                                        r5 = heapClassInst.heap32[r3];
                                                        r8 = r7 << numDefine2;
                                                        r5 = (r5 + 1) | 0;
                                                        r8 = r8 | numDefine3;
                                                        heapClassInst.heap32[r3] = r5;
                                                        r5 = (r8 + numDefine16) | 0;
                                                        heapClassInst.heap32[g0] = r5;
                                                        mallocNew(i7);
                                                        r8 = commonVariable.rg0;
                                                        if (r8 != 0) {
                                                            r5 = 0;
                                                            r9 = (r8 + numDefine4) | 0;
                                                            r5 = (r5 - r9) | 0;
                                                            r5 = r5 & numDefine15;
                                                            r5 = (r8 + r5) | 0;
                                                            r9 = (r5 + numDefine4) | 0;
                                                            r5 = r5 >> numDefine2;
                                                            heapClassInst.heap32[r5] = r8;
                                                            r8 = r9;
                                                        }
                                                    } else {
                                                        r8 = 0;
                                                    }
                                                    repeat43: do {
                                                        if (!(r0 < 1)) {
                                                            r5 = r1;
                                                            r9 = r8;
                                                            r10 = r0;
                                                            while (true) {
                                                                r11 = r5 >> numDefine2;
                                                                r10 = (r10 + -1) | 0;
                                                                r12 = (r9 + numDefine4) | 0;
                                                                r5 = (r5 + numDefine4) | 0;
                                                                r9 = r9 >> numDefine2;
                                                                r11 = heapClassInst.heap32[r11];
                                                                heapClassInst.heap32[r9] = r11;
                                                                r9 = r12;
                                                                if (!(r10 != 0)) {
                                                                    break repeat43;
                                                                }
                                                            }
                                                        }
                                                    } while (false);
                                                    if (r1 != 0) {
                                                        r5 = gNumAlignedFree;
                                                        r5 = r5 >> numDefine2;
                                                        r9 = heapClassInst.heap32[r5];
                                                        r9 = (r9 + 1) | 0;
                                                        r1 = r1 >> numDefine2;
                                                        heapClassInst.heap32[r5] = r9;
                                                        r1 = heapClassInst.heap32[r1 + -1];
                                                        heapClassInst.heap32[g0] = r1;
                                                        free(i7);
                                                        r5 = r7;
                                                        r1 = r8;
                                                    } else {
                                                        r5 = r7;
                                                        r1 = r8;
                                                    }
                                                }
                                            }
                                            r7 = (r1 + r4) | 0;
                                            r4 = (r0 + 1) | 0;
                                            r0 = r7 >> numDefine2;
                                            heapClassInst.heap32[r0] = r6;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                if (!(r4 > 0)) {
                    break repeat6;
                }
            }
            if (!(r1 == 0)) {
                r0 = gNumAlignedFree;
                r0 = r0 >> numDefine2;
                r2 = heapClassInst.heap32[r0];
                r2 = (r2 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r0] = r2;
                r0 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r0;
                free(i7);
            }
        }
        return;
    }

    public static void znk14btQuantizedBvh9serializeEPvjb(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine38];
        r3 = heapClassInst.heap32[r1 + numDefine42];
        if (r3 == r2) {
            r3 = heapClassInst.heap32[fp + 1];
            r4 = heapClassInst.heap32[fp + numDefine3];
            r5 = ztv14btQuantizedBvh;
            r6 = r3 >> numDefine2;
            r5 = (r5 + numDefine8) | 0;
            heapClassInst.heap32[r1 + numDefine42] = r2;
            heapClassInst.heap32[r6] = r5;
            r2 = 0;
            heapClassInst.heap32[r6 + numDefine13] = numDefine277;
            r5 = 1;
            heapClassInst.heap8[r3 + numDefine60] = (byte)r2;
            heapClassInst.heap8[r3 + numDefine80] = (byte)r5;
            heapClassInst.heap32[r6 + numDefine19] = 0;
            heapClassInst.heap32[r6 + numDefine17] = 0;
            heapClassInst.heap32[r6 + numDefine18] = 0;
            heapClassInst.heap8[r3 + numDefine100] = (byte)r5;
            heapClassInst.heap32[r6 + numDefine24] = 0;
            heapClassInst.heap32[r6 + numDefine22] = 0;
            heapClassInst.heap32[r6 + numDefine23] = 0;
            heapClassInst.heap8[r3 + numDefine120] = (byte)r5;
            heapClassInst.heap32[r6 + numDefine29] = 0;
            heapClassInst.heap32[r6 + numDefine27] = 0;
            heapClassInst.heap32[r6 + numDefine28] = 0;
            heapClassInst.heap8[r3 + numDefine140] = (byte)r5;
            heapClassInst.heap32[r6 + numDefine34] = 0;
            heapClassInst.heap32[r6 + numDefine32] = 0;
            heapClassInst.heap32[r6 + numDefine33] = 0;
            heapClassInst.heap32[r6 + numDefine36] = 0;
            heapClassInst.heap8[r3 + numDefine164] = (byte)r5;
            heapClassInst.heap32[r6 + numDefine40] = 0;
            heapClassInst.heap32[r6 + numDefine38] = 0;
            heapClassInst.heap32[r6 + numDefine39] = 0;
            heapClassInst.heap32[r6 + numDefine42] = 0;
            heapClassInst.heap32[r6 + 1] = numDefineNeg88609;
            heapClassInst.heap32[r6 + numDefine2] = numDefineNeg88609;
            heapClassInst.heap32[r6 + numDefine3] = numDefineNeg88609;
            heapClassInst.heap32[r6 + numDefine4] = 0;
            heapClassInst.heap32[r6 + numDefine5] = numDefine95039;
            heapClassInst.heap32[r6 + numDefine6] = numDefine95039;
            heapClassInst.heap32[r6 + numDefine7] = numDefine95039;
            heapClassInst.heap32[r6 + numDefine8] = 0;
            r7 = heapClassInst.heap32[r1 + numDefine14];
            if (r4 == 0) {
                heapClassInst.heap32[r6 + numDefine14] = r7;
                heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r1 + 1];
                heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
                heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r1 + numDefine3];
                heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r1 + numDefine4];
                heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r1 + numDefine6];
                heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r1 + numDefine7];
                heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r1 + numDefine8];
                heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r1 + numDefine9];
                heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r1 + numDefine10];
                heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r1 + numDefine11];
                heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r1 + numDefine12];
                r7 = heapClassInst.heap32[r1 + numDefine36];
                heapClassInst.heap32[r6 + numDefine36] = r7;
                r7 = heapClassInst.heap32[r1 + numDefine42];
            } else {
                r8 = r7 << numDefine8;
                r9 = r7 >>> numDefine8;
                r10 = r7 << numDefine24;
                r8 = r8 & numDefine11680;
                r9 = r9 & numDefine65280;
                r7 = r7 >>> numDefine24;
                r8 = r10 | r8;
                r7 = r9 | r7;
                r7 = r8 | r7;
                heapClassInst.heap32[r6 + numDefine14] = r7;
                r7 = heapClassInst.heapU8[r0 + numDefine7];
                heapClassInst.heap8[r3 + numDefine4] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine6];
                heapClassInst.heap8[r3 + numDefine5] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine5];
                heapClassInst.heap8[r3 + numDefine6] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine4];
                heapClassInst.heap8[r3 + numDefine7] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine11];
                heapClassInst.heap8[r3 + numDefine8] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine10];
                heapClassInst.heap8[r3 + numDefine9] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine9];
                heapClassInst.heap8[r3 + numDefine10] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine8];
                heapClassInst.heap8[r3 + numDefine11] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine15];
                heapClassInst.heap8[r3 + numDefine12] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine14];
                heapClassInst.heap8[r3 + numDefine13] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine13];
                heapClassInst.heap8[r3 + numDefine14] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine12];
                heapClassInst.heap8[r3 + numDefine15] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine19];
                heapClassInst.heap8[r3 + numDefine16] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine18];
                heapClassInst.heap8[r3 + numDefine17] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine17];
                heapClassInst.heap8[r3 + numDefine18] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine16];
                heapClassInst.heap8[r3 + numDefine19] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine23];
                heapClassInst.heap8[r3 + numDefine20] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine22];
                heapClassInst.heap8[r3 + numDefine21] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine21];
                heapClassInst.heap8[r3 + numDefine22] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine20];
                heapClassInst.heap8[r3 + numDefine23] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine27];
                heapClassInst.heap8[r3 + numDefine24] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine26];
                heapClassInst.heap8[r3 + numDefine25] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine25];
                heapClassInst.heap8[r3 + numDefine26] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine24];
                heapClassInst.heap8[r3 + numDefine27] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine31];
                heapClassInst.heap8[r3 + numDefine28] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine30];
                heapClassInst.heap8[r3 + numDefine29] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine29];
                heapClassInst.heap8[r3 + numDefine30] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine28];
                heapClassInst.heap8[r3 + numDefine31] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine35];
                heapClassInst.heap8[r3 + numDefine32] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine34];
                heapClassInst.heap8[r3 + numDefine33] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine33];
                heapClassInst.heap8[r3 + numDefine34] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine32];
                heapClassInst.heap8[r3 + numDefine35] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine39];
                heapClassInst.heap8[r3 + numDefine36] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine38];
                heapClassInst.heap8[r3 + numDefine37] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine37];
                heapClassInst.heap8[r3 + numDefine38] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine36];
                heapClassInst.heap8[r3 + numDefine39] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine43];
                heapClassInst.heap8[r3 + numDefine40] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine42];
                heapClassInst.heap8[r3 + numDefine41] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine41];
                heapClassInst.heap8[r3 + numDefine42] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine40];
                heapClassInst.heap8[r3 + numDefine43] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine47];
                heapClassInst.heap8[r3 + numDefine44] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine46];
                heapClassInst.heap8[r3 + numDefine45] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine45];
                heapClassInst.heap8[r3 + numDefine46] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine44];
                heapClassInst.heap8[r3 + numDefine47] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine51];
                heapClassInst.heap8[r3 + numDefine48] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine50];
                heapClassInst.heap8[r3 + numDefine49] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine49];
                heapClassInst.heap8[r3 + numDefine50] = (byte)r7;
                r7 = heapClassInst.heapU8[r0 + numDefine48];
                heapClassInst.heap8[r3 + numDefine51] = (byte)r7;
                r7 = heapClassInst.heap32[r1 + numDefine36];
                r8 = r7 << numDefine8;
                r9 = r7 >>> numDefine8;
                r10 = r7 << numDefine24;
                r8 = r8 & numDefine11680;
                r9 = r9 & numDefine65280;
                r7 = r7 >>> numDefine24;
                r8 = r10 | r8;
                r7 = r9 | r7;
                r7 = r8 | r7;
                heapClassInst.heap32[r6 + numDefine36] = r7;
                r7 = heapClassInst.heap32[r1 + numDefine42];
                r8 = r7 << numDefine8;
                r9 = r7 >>> numDefine8;
                r10 = r7 << numDefine24;
                r8 = r8 & numDefine11680;
                r9 = r9 & numDefine65280;
                r7 = r7 >>> numDefine24;
                r8 = r10 | r8;
                r7 = r9 | r7;
                r7 = r8 | r7;
            }
            heapClassInst.heap32[r6 + numDefine42] = r7;
            r7 = heapClassInst.heapU8[r0 + numDefine60];
            heapClassInst.heap8[r3 + numDefine60] = (byte)r7;
            r7 = (r3 + numDefine172) | 0;
            r8 = heapClassInst.heap32[r1 + numDefine14];
            r0 = heapClassInst.heapU8[r0 + numDefine60];
            if (r0 == 0) {
                r0 = 0;
                heapClassInst.heap8[r3 + numDefine100] = (byte)r0;
                heapClassInst.heap32[r6 + numDefine24] = r7;
                heapClassInst.heap32[r6 + numDefine22] = r8;
                heapClassInst.heap32[r6 + numDefine23] = r8;
                repeat9: do {
                    if (r4 != 0) {
                        if (!(r8 < 1)) {
                            r5 = (r5 - r8) | 0;
                            while (true) {
                                r2 = r0 << numDefine6;
                                r9 = heapClassInst.heap32[r1 + numDefine24];
                                r9 = (r9 - r2) | 0;
                                r10 = heapClassInst.heapU8[r9 + numDefine3];
                                r7 = (r7 - r2) | 0;
                                heapClassInst.heap8[r7] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine2];
                                heapClassInst.heap8[r7 + 1] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + 1];
                                heapClassInst.heap8[r7 + numDefine2] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9];
                                heapClassInst.heap8[r7 + numDefine3] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine7];
                                heapClassInst.heap8[r7 + numDefine4] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine6];
                                heapClassInst.heap8[r7 + numDefine5] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine5];
                                heapClassInst.heap8[r7 + numDefine6] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine4];
                                heapClassInst.heap8[r7 + numDefine7] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine11];
                                heapClassInst.heap8[r7 + numDefine8] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine10];
                                heapClassInst.heap8[r7 + numDefine9] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine9];
                                heapClassInst.heap8[r7 + numDefine10] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine8];
                                heapClassInst.heap8[r7 + numDefine11] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine15];
                                heapClassInst.heap8[r7 + numDefine12] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine14];
                                heapClassInst.heap8[r7 + numDefine13] = (byte)r10;
                                r10 = heapClassInst.heapU8[r9 + numDefine13];
                                heapClassInst.heap8[r7 + numDefine14] = (byte)r10;
                                r9 = heapClassInst.heapU8[r9 + numDefine12];
                                heapClassInst.heap8[r7 + numDefine15] = (byte)r9;
                                r7 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r9 = heapClassInst.heap32[r6 + numDefine24];
                                r10 = heapClassInst.heapU8[r7 + numDefine19];
                                r9 = (r9 - r2) | 0;
                                heapClassInst.heap8[r9 + numDefine16] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine18];
                                heapClassInst.heap8[r9 + numDefine17] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine17];
                                heapClassInst.heap8[r9 + numDefine18] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine16];
                                heapClassInst.heap8[r9 + numDefine19] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine23];
                                heapClassInst.heap8[r9 + numDefine20] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine22];
                                heapClassInst.heap8[r9 + numDefine21] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine21];
                                heapClassInst.heap8[r9 + numDefine22] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine20];
                                heapClassInst.heap8[r9 + numDefine23] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine27];
                                heapClassInst.heap8[r9 + numDefine24] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine26];
                                heapClassInst.heap8[r9 + numDefine25] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine25];
                                heapClassInst.heap8[r9 + numDefine26] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine24];
                                heapClassInst.heap8[r9 + numDefine27] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine31];
                                heapClassInst.heap8[r9 + numDefine28] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine30];
                                heapClassInst.heap8[r9 + numDefine29] = (byte)r10;
                                r10 = heapClassInst.heapU8[r7 + numDefine29];
                                heapClassInst.heap8[r9 + numDefine30] = (byte)r10;
                                r7 = heapClassInst.heapU8[r7 + numDefine28];
                                heapClassInst.heap8[r9 + numDefine31] = (byte)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r7 = heapClassInst.heap32[r7 + numDefine8];
                                r9 = r7 << numDefine8;
                                r10 = r7 >>> numDefine8;
                                r11 = heapClassInst.heap32[r6 + numDefine24];
                                r12 = r7 << numDefine24;
                                r9 = r9 & numDefine11680;
                                r10 = r10 & numDefine65280;
                                r7 = r7 >>> numDefine24;
                                r11 = (r11 - r2) | 0;
                                r9 = r12 | r9;
                                r7 = r10 | r7;
                                r10 = r11 >> numDefine2;
                                r7 = r9 | r7;
                                heapClassInst.heap32[r10 + numDefine8] = r7;
                                r7 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r7 = heapClassInst.heap32[r7 + numDefine9];
                                r9 = r7 << numDefine8;
                                r10 = r7 >>> numDefine8;
                                r11 = heapClassInst.heap32[r6 + numDefine24];
                                r12 = r7 << numDefine24;
                                r9 = r9 & numDefine11680;
                                r10 = r10 & numDefine65280;
                                r7 = r7 >>> numDefine24;
                                r11 = (r11 - r2) | 0;
                                r9 = r12 | r9;
                                r7 = r10 | r7;
                                r10 = r11 >> numDefine2;
                                r7 = r9 | r7;
                                heapClassInst.heap32[r10 + numDefine9] = r7;
                                r7 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r7 = heapClassInst.heap32[r7 + numDefine10];
                                r9 = r7 << numDefine8;
                                r10 = r7 >>> numDefine8;
                                r11 = heapClassInst.heap32[r6 + numDefine24];
                                r12 = r7 << numDefine24;
                                r9 = r9 & numDefine11680;
                                r10 = r10 & numDefine65280;
                                r7 = r7 >>> numDefine24;
                                r2 = (r11 - r2) | 0;
                                r9 = r12 | r9;
                                r7 = r10 | r7;
                                r2 = r2 >> numDefine2;
                                r7 = r9 | r7;
                                heapClassInst.heap32[r2 + numDefine10] = r7;
                                if (r5 == r0) {
                                    break repeat9;
                                } else {
                                    r7 = heapClassInst.heap32[r6 + numDefine24];
                                    r0 = (r0 + -1) | 0;
                                }
                            }
                        }
                    } else {
                        if (r8 > 0) {
                            r5 = (r5 - r8) | 0;
                            r0 = 0;
                            while (true) {
                                r2 = r0 << numDefine6;
                                r9 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r9 = (r9 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r9 = r9 >> numDefine2;
                                heapClassInst.heap32[r7] = heapClassInst.heap32[r9];
                                heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r9 + 1];
                                heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r9 + numDefine2];
                                heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r9 + numDefine3];
                                r7 = heapClassInst.heap32[r6 + numDefine24];
                                r9 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r9 = (r9 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r9 = r9 >> numDefine2;
                                heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r9 + numDefine4];
                                heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r9 + numDefine5];
                                heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r9 + numDefine6];
                                heapClassInst.heap32[r7 + numDefine7] = heapClassInst.heap32[r9 + numDefine7];
                                r7 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r9 = heapClassInst.heap32[r6 + numDefine24];
                                r9 = (r9 - r2) | 0;
                                r7 = heapClassInst.heap32[r7 + numDefine8];
                                r9 = r9 >> numDefine2;
                                heapClassInst.heap32[r9 + numDefine8] = r7;
                                r7 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r9 = heapClassInst.heap32[r6 + numDefine24];
                                r9 = (r9 - r2) | 0;
                                r7 = heapClassInst.heap32[r7 + numDefine9];
                                r9 = r9 >> numDefine2;
                                heapClassInst.heap32[r9 + numDefine9] = r7;
                                r7 = heapClassInst.heap32[r1 + numDefine24];
                                r7 = (r7 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r9 = heapClassInst.heap32[r6 + numDefine24];
                                r2 = (r9 - r2) | 0;
                                r7 = heapClassInst.heap32[r7 + numDefine10];
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2 + numDefine10] = r7;
                                if (r5 == r0) {
                                    break repeat9;
                                } else {
                                    r7 = heapClassInst.heap32[r6 + numDefine24];
                                    r0 = (r0 + -1) | 0;
                                }
                            }
                        }
                    }
                } while (false);
                r5 = heapClassInst.heap32[r6 + numDefine24];
                if (!(r5 == 0)) {
                    r0 = heapClassInst.heapU8[r3 + numDefine100];
                    if (!(r0 == 0)) {
                        r0 = gNumAlignedFree;
                        r0 = r0 >> numDefine2;
                        r2 = heapClassInst.heap32[r0];
                        r2 = (r2 + 1) | 0;
                        r5 = r5 >> numDefine2;
                        heapClassInst.heap32[r0] = r2;
                        r5 = heapClassInst.heap32[r5 + -1];
                        heapClassInst.heap32[g0] = r5;
                        free(i7);
                    }
                    heapClassInst.heap32[r6 + numDefine24] = 0;
                }
                r5 = r8 << numDefine6;
                r0 = 0;
                heapClassInst.heap8[r3 + numDefine100] = (byte)r0;
                heapClassInst.heap32[r6 + numDefine24] = 0;
                heapClassInst.heap32[r6 + numDefine22] = 0;
                heapClassInst.heap32[r6 + numDefine23] = 0;
            } else {
                heapClassInst.heap8[r3 + numDefine140] = (byte)r2;
                heapClassInst.heap32[r6 + numDefine34] = r7;
                heapClassInst.heap32[r6 + numDefine32] = r8;
                heapClassInst.heap32[r6 + numDefine33] = r8;
                repeat28: do {
                    if (r4 != 0) {
                        if (!(r8 < 1)) {
                            r5 = (r5 - r8) | 0;
                            while (true) {
                                r0 = heapClassInst.heap32[r1 + numDefine34];
                                r9 = r2 << numDefine4;
                                r0 = (r0 - r9) | 0;
                                r0 = heapClassInst.heapU16[r0 >> 1];
                                r10 = r0 << numDefine8;
                                r0 = r0 << numDefine24;
                                r10 = r10 & numDefine11680;
                                r0 = r0 | r10;
                                r7 = (r7 - r9) | 0;
                                r0 = r0 >>> numDefine16;
                                heapClassInst.heap16[r7 >> 1] = (short)r0;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r9) | 0;
                                r7 = heapClassInst.heapU16[(r7 + numDefine2) >> 1];
                                r0 = r7 << numDefine8;
                                r7 = r7 << numDefine24;
                                r0 = r0 & numDefine11680;
                                r10 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = r7 | r0;
                                r0 = (r10 - r9) | 0;
                                r7 = r7 >>> numDefine16;
                                heapClassInst.heap16[(r0 + numDefine2) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r9) | 0;
                                r7 = heapClassInst.heapU16[(r7 + numDefine4) >> 1];
                                r0 = r7 << numDefine8;
                                r7 = r7 << numDefine24;
                                r0 = r0 & numDefine11680;
                                r10 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = r7 | r0;
                                r0 = (r10 - r9) | 0;
                                r7 = r7 >>> numDefine16;
                                heapClassInst.heap16[(r0 + numDefine4) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r9) | 0;
                                r7 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
                                r0 = r7 << numDefine8;
                                r7 = r7 << numDefine24;
                                r0 = r0 & numDefine11680;
                                r10 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = r7 | r0;
                                r0 = (r10 - r9) | 0;
                                r7 = r7 >>> numDefine16;
                                heapClassInst.heap16[(r0 + numDefine6) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r9) | 0;
                                r7 = heapClassInst.heapU16[(r7 + numDefine8) >> 1];
                                r0 = r7 << numDefine8;
                                r7 = r7 << numDefine24;
                                r0 = r0 & numDefine11680;
                                r10 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = r7 | r0;
                                r0 = (r10 - r9) | 0;
                                r7 = r7 >>> numDefine16;
                                heapClassInst.heap16[(r0 + numDefine8) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r9) | 0;
                                r7 = heapClassInst.heapU16[(r7 + numDefine10) >> 1];
                                r0 = r7 << numDefine8;
                                r7 = r7 << numDefine24;
                                r0 = r0 & numDefine11680;
                                r10 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = r7 | r0;
                                r0 = (r10 - r9) | 0;
                                r7 = r7 >>> numDefine16;
                                heapClassInst.heap16[(r0 + numDefine10) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r9) | 0;
                                r7 = r7 >> numDefine2;
                                r7 = heapClassInst.heap32[r7 + numDefine3];
                                r0 = r7 << numDefine8;
                                r10 = r7 >>> numDefine8;
                                r11 = heapClassInst.heap32[r6 + numDefine34];
                                r12 = r7 << numDefine24;
                                r0 = r0 & numDefine11680;
                                r10 = r10 & numDefine65280;
                                r7 = r7 >>> numDefine24;
                                r9 = (r11 - r9) | 0;
                                r0 = r12 | r0;
                                r7 = r10 | r7;
                                r9 = r9 >> numDefine2;
                                r7 = r0 | r7;
                                heapClassInst.heap32[r9 + numDefine3] = r7;
                                if (r5 == r2) {
                                    break repeat28;
                                } else {
                                    r7 = heapClassInst.heap32[r6 + numDefine34];
                                    r2 = (r2 + -1) | 0;
                                }
                            }
                        }
                    } else {
                        if (r8 > 0) {
                            r5 = (r5 - r8) | 0;
                            r0 = 0;
                            while (true) {
                                r2 = r0 << numDefine4;
                                r9 = heapClassInst.heap32[r1 + numDefine34];
                                r9 = (r9 - r2) | 0;
                                r9 = heapClassInst.heapU16[r9 >> 1];
                                r7 = (r7 - r2) | 0;
                                heapClassInst.heap16[r7 >> 1] = (short)r9;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r2) | 0;
                                r9 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = heapClassInst.heapU16[(r7 + numDefine2) >> 1];
                                r9 = (r9 - r2) | 0;
                                heapClassInst.heap16[(r9 + numDefine2) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r2) | 0;
                                r9 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = heapClassInst.heapU16[(r7 + numDefine4) >> 1];
                                r9 = (r9 - r2) | 0;
                                heapClassInst.heap16[(r9 + numDefine4) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r2) | 0;
                                r9 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = heapClassInst.heapU16[(r7 + numDefine6) >> 1];
                                r9 = (r9 - r2) | 0;
                                heapClassInst.heap16[(r9 + numDefine6) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r2) | 0;
                                r9 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = heapClassInst.heapU16[(r7 + numDefine8) >> 1];
                                r9 = (r9 - r2) | 0;
                                heapClassInst.heap16[(r9 + numDefine8) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r2) | 0;
                                r9 = heapClassInst.heap32[r6 + numDefine34];
                                r7 = heapClassInst.heapU16[(r7 + numDefine10) >> 1];
                                r9 = (r9 - r2) | 0;
                                heapClassInst.heap16[(r9 + numDefine10) >> 1] = (short)r7;
                                r7 = heapClassInst.heap32[r1 + numDefine34];
                                r7 = (r7 - r2) | 0;
                                r7 = r7 >> numDefine2;
                                r9 = heapClassInst.heap32[r6 + numDefine34];
                                r2 = (r9 - r2) | 0;
                                r7 = heapClassInst.heap32[r7 + numDefine3];
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2 + numDefine3] = r7;
                                if (r5 == r0) {
                                    break repeat28;
                                } else {
                                    r7 = heapClassInst.heap32[r6 + numDefine34];
                                    r0 = (r0 + -1) | 0;
                                }
                            }
                        }
                    }
                } while (false);
                r5 = heapClassInst.heap32[r6 + numDefine34];
                if (!(r5 == 0)) {
                    r7 = heapClassInst.heapU8[r3 + numDefine140];
                    if (!(r7 == 0)) {
                        r7 = gNumAlignedFree;
                        r7 = r7 >> numDefine2;
                        r0 = heapClassInst.heap32[r7];
                        r0 = (r0 + 1) | 0;
                        r5 = r5 >> numDefine2;
                        heapClassInst.heap32[r7] = r0;
                        r5 = heapClassInst.heap32[r5 + -1];
                        heapClassInst.heap32[g0] = r5;
                        free(i7);
                    }
                    heapClassInst.heap32[r6 + numDefine34] = 0;
                }
                r5 = r8 << numDefine4;
                r7 = 0;
                heapClassInst.heap8[r3 + numDefine140] = (byte)r7;
                heapClassInst.heap32[r6 + numDefine34] = 0;
                heapClassInst.heap32[r6 + numDefine32] = 0;
                heapClassInst.heap32[r6 + numDefine33] = 0;
            }
            r0 = heapClassInst.heap32[r6 + numDefine40];
            r2 = heapClassInst.heap32[r1 + numDefine42];
            if (!(r0 == 0)) {
                r7 = heapClassInst.heapU8[r3 + numDefine164];
                if (!(r7 == 0)) {
                    r7 = gNumAlignedFree;
                    r7 = r7 >> numDefine2;
                    r8 = heapClassInst.heap32[r7];
                    r8 = (r8 + 1) | 0;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r7] = r8;
                    r0 = heapClassInst.heap32[r0 + -1];
                    heapClassInst.heap32[g0] = r0;
                    free(i7);
                }
                heapClassInst.heap32[r6 + numDefine40] = 0;
            }
            r0 = (r5 + r3) | 0;
            r0 = (r0 + numDefine172) | 0;
            r5 = 0;
            heapClassInst.heap8[r3 + numDefine164] = (byte)r5;
            heapClassInst.heap32[r6 + numDefine40] = r0;
            heapClassInst.heap32[r6 + numDefine38] = r2;
            heapClassInst.heap32[r6 + numDefine39] = r2;
            r2 = heapClassInst.heap32[r1 + numDefine42];
            repeat53: do {
                if (r4 != 0) {
                    if (!(r2 < 1)) {
                        label = numDefine41;
                        while (true) {
                            r2 = r5 << numDefine5;
                            r4 = heapClassInst.heap32[r1 + numDefine40];
                            r4 = heapClassInst.heapU16[(r4 + r2) >> 1];
                            r7 = r4 << numDefine8;
                            r4 = r4 << numDefine24;
                            r7 = r7 & numDefine11680;
                            r4 = r4 | r7;
                            r4 = r4 >>> numDefine16;
                            heapClassInst.heap16[(r0 + r2) >> 1] = (short)r4;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r2) | 0;
                            r0 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
                            r4 = r0 << numDefine8;
                            r0 = r0 << numDefine24;
                            r4 = r4 & numDefine11680;
                            r7 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = r0 | r4;
                            r4 = (r7 + r2) | 0;
                            r0 = r0 >>> numDefine16;
                            heapClassInst.heap16[(r4 + numDefine2) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r2) | 0;
                            r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                            r4 = r0 << numDefine8;
                            r0 = r0 << numDefine24;
                            r4 = r4 & numDefine11680;
                            r7 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = r0 | r4;
                            r4 = (r7 + r2) | 0;
                            r0 = r0 >>> numDefine16;
                            heapClassInst.heap16[(r4 + numDefine4) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r2) | 0;
                            r0 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
                            r4 = r0 << numDefine8;
                            r0 = r0 << numDefine24;
                            r4 = r4 & numDefine11680;
                            r7 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = r0 | r4;
                            r4 = (r7 + r2) | 0;
                            r0 = r0 >>> numDefine16;
                            heapClassInst.heap16[(r4 + numDefine6) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r2) | 0;
                            r0 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
                            r4 = r0 << numDefine8;
                            r0 = r0 << numDefine24;
                            r4 = r4 & numDefine11680;
                            r7 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = r0 | r4;
                            r4 = (r7 + r2) | 0;
                            r0 = r0 >>> numDefine16;
                            heapClassInst.heap16[(r4 + numDefine8) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r2) | 0;
                            r0 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
                            r4 = r0 << numDefine8;
                            r0 = r0 << numDefine24;
                            r4 = r4 & numDefine11680;
                            r7 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = r0 | r4;
                            r4 = (r7 + r2) | 0;
                            r0 = r0 >>> numDefine16;
                            heapClassInst.heap16[(r4 + numDefine10) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r2) | 0;
                            r0 = r0 >> numDefine2;
                            r0 = heapClassInst.heap32[r0 + numDefine3];
                            r4 = r0 << numDefine8;
                            r7 = r0 >>> numDefine8;
                            r8 = heapClassInst.heap32[r6 + numDefine40];
                            r9 = r0 << numDefine24;
                            r4 = r4 & numDefine11680;
                            r7 = r7 & numDefine65280;
                            r0 = r0 >>> numDefine24;
                            r8 = (r8 + r2) | 0;
                            r4 = r9 | r4;
                            r0 = r7 | r0;
                            r7 = r8 >> numDefine2;
                            r0 = r4 | r0;
                            heapClassInst.heap32[r7 + numDefine3] = r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r2) | 0;
                            r0 = r0 >> numDefine2;
                            r0 = heapClassInst.heap32[r0 + numDefine4];
                            r4 = r0 << numDefine8;
                            r7 = r0 >>> numDefine8;
                            r8 = heapClassInst.heap32[r6 + numDefine40];
                            r9 = r0 << numDefine24;
                            r4 = r4 & numDefine11680;
                            r7 = r7 & numDefine65280;
                            r0 = r0 >>> numDefine24;
                            r2 = (r8 + r2) | 0;
                            r4 = r9 | r4;
                            r0 = r7 | r0;
                            r5 = (r5 + 1) | 0;
                            r2 = r2 >> numDefine2;
                            r0 = r4 | r0;
                            heapClassInst.heap32[r2 + numDefine4] = r0;
                            r0 = heapClassInst.heap32[r1 + numDefine42];
                            if (r0 <= r5) {
                                break repeat53;
                            } else {
                                r0 = heapClassInst.heap32[r6 + numDefine40];
                            }
                        }
                    }
                } else {
                    if (r2 > 0) {
                        r2 = 0;
                        while (true) {
                            r4 = r2 << numDefine5;
                            r5 = heapClassInst.heap32[r1 + numDefine40];
                            r5 = heapClassInst.heapU16[(r5 + r4) >> 1];
                            heapClassInst.heap16[(r0 + r4) >> 1] = (short)r5;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r5 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
                            r5 = (r5 + r4) | 0;
                            heapClassInst.heap16[(r5 + numDefine2) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r5 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                            r5 = (r5 + r4) | 0;
                            heapClassInst.heap16[(r5 + numDefine4) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r5 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
                            r5 = (r5 + r4) | 0;
                            heapClassInst.heap16[(r5 + numDefine6) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r5 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
                            r5 = (r5 + r4) | 0;
                            heapClassInst.heap16[(r5 + numDefine8) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r5 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
                            r5 = (r5 + r4) | 0;
                            heapClassInst.heap16[(r5 + numDefine10) >> 1] = (short)r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r0 = r0 >> numDefine2;
                            r5 = heapClassInst.heap32[r6 + numDefine40];
                            r5 = (r5 + r4) | 0;
                            r0 = heapClassInst.heap32[r0 + numDefine3];
                            r5 = r5 >> numDefine2;
                            heapClassInst.heap32[r5 + numDefine3] = r0;
                            r0 = heapClassInst.heap32[r1 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r0 = r0 >> numDefine2;
                            r5 = heapClassInst.heap32[r6 + numDefine40];
                            r5 = (r5 + r4) | 0;
                            r0 = heapClassInst.heap32[r0 + numDefine4];
                            r5 = r5 >> numDefine2;
                            heapClassInst.heap32[r5 + numDefine4] = r0;
                            r0 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r0 = r0 >> numDefine2;
                            heapClassInst.heap32[r0 + numDefine5] = 0;
                            r0 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r0 = r0 >> numDefine2;
                            heapClassInst.heap32[r0 + numDefine6] = 0;
                            r0 = heapClassInst.heap32[r6 + numDefine40];
                            r0 = (r0 + r4) | 0;
                            r2 = (r2 + 1) | 0;
                            r0 = r0 >> numDefine2;
                            heapClassInst.heap32[r0 + numDefine7] = 0;
                            r0 = heapClassInst.heap32[r1 + numDefine42];
                            if (r0 <= r2) {
                                break repeat53;
                            } else {
                                r0 = heapClassInst.heap32[r6 + numDefine40];
                            }
                        }
                    }
                }
            } while (false);
            r0 = heapClassInst.heap32[r6 + numDefine40];
            if (!(r0 == 0)) {
                r1 = heapClassInst.heapU8[r3 + numDefine164];
                if (!(r1 == 0)) {
                    r1 = gNumAlignedFree;
                    r1 = r1 >> numDefine2;
                    r2 = heapClassInst.heap32[r1];
                    r2 = (r2 + 1) | 0;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r1] = r2;
                    r0 = heapClassInst.heap32[r0 + -1];
                    heapClassInst.heap32[g0] = r0;
                    free(i7);
                }
                heapClassInst.heap32[r6 + numDefine40] = 0;
            }
            r0 = 0;
            heapClassInst.heap8[r3 + numDefine164] = (byte)r0;
            heapClassInst.heap32[r6 + numDefine40] = 0;
            heapClassInst.heap32[r6 + numDefine38] = 0;
            heapClassInst.heap32[r6 + numDefine39] = 0;
            heapClassInst.heap32[r6] = 0;
            r0 = 1;
            commonVariable.rg0 = r0;
            
        } else {
            r0 = twoEStr638;
            r1 = twoEStr537;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine847;
            assertNew(i7);
        }
        
    }

    public static void z15btTransformAabbRK9btVector3S1FRK11btTransformRSS5(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        double f10 = 0.0;
        double f11 = 0.0;
        double f12 = 0.0;
        double f13 = 0.0;
        double f14 = 0.0;
        double f15 = 0.0;
        double f16 = 0.0;
        double f17 = 0.0;
        double f18 = 0.0;
        double f19 = 0.0;
        double f20 = 0.0;
        double f21 = 0.0;
        double f22 = 0.0;
        double f23 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0];
        f1 = heapClassInst.heapFloat[r1];
        if (f0 <= f1) {
            f2 = heapClassInst.heapFloat[r0 + 1];
            f3 = heapClassInst.heapFloat[r1 + 1];
            if (f2 <= f3) {
                f4 = heapClassInst.heapFloat[r0 + numDefine2];
                f5 = heapClassInst.heapFloat[r1 + numDefine2];
                if (f4 <= f5) {
                    f6 = heapClassInst.heapFloat[fp + numDefine2];
                    r0 = heapClassInst.heap32[fp + numDefine3];
                    r1 = heapClassInst.heap32[fp + numDefine4];
                    r2 = heapClassInst.heap32[fp + numDefine5];
                    f7 = f1 - f0;
                    f8 = numDefineFloat05;
                    f9 = f3 - f2;
                    f10 = f5 - f4;
                    r0 = r0 >> numDefine2;
                    f4 = f5 + f4;
                    f2 = f3 + f2;
                    f0 = f1 + f0;
                    f1 = f7 * f8;
                    f3 = f9 * f8;
                    f5 = f10 * f8;
                    f7 = heapClassInst.heapFloat[r0 + numDefine10];
                    f1 = f1 + f6;
                    f3 = f3 + f6;
                    f5 = f5 + f6;
                    f4 = f4 * f8;
                    f2 = f2 * f8;
                    f0 = f0 * f8;
                    f6 = 0;
                    if (f7 < f6) {
                        f8 = -f7;
                    } else {
                        f8 = f7;
                    }
                    f9 = heapClassInst.heapFloat[r0 + numDefine9];
                    if (f9 < f6) {
                        f10 = -f9;
                    } else {
                        f10 = f9;
                    }
                    f11 = heapClassInst.heapFloat[r0 + numDefine8];
                    if (f11 < f6) {
                        f12 = -f11;
                    } else {
                        f12 = f11;
                    }
                    f13 = heapClassInst.heapFloat[r0 + numDefine6];
                    if (f13 < f6) {
                        f14 = -f13;
                    } else {
                        f14 = f13;
                    }
                    f15 = heapClassInst.heapFloat[r0 + numDefine5];
                    if (f15 < f6) {
                        f16 = -f15;
                    } else {
                        f16 = f15;
                    }
                    f17 = heapClassInst.heapFloat[r0 + numDefine4];
                    if (f17 < f6) {
                        f18 = -f17;
                    } else {
                        f18 = f17;
                    }
                    f19 = heapClassInst.heapFloat[r0 + numDefine2];
                    if (f19 < f6) {
                        f20 = -f19;
                    } else {
                        f20 = f19;
                    }
                    f21 = heapClassInst.heapFloat[r0 + 1];
                    if (f21 < f6) {
                        f22 = -f21;
                    } else {
                        f22 = f21;
                    }
                    f23 = heapClassInst.heapFloat[r0];
                    if (f23 < f6) {
                        f6 = -f23;
                    } else {
                        f6 = f23;
                    }
                    f23 = f23 * f0;
                    f21 = f21 * f2;
                    f17 = f17 * f0;
                    f15 = f15 * f2;
                    f21 = f23 + f21;
                    f19 = f19 * f4;
                    f6 = f6 * f1;
                    f22 = f22 * f3;
                    f0 = f11 * f0;
                    f2 = f9 * f2;
                    f9 = f17 + f15;
                    f11 = f13 * f4;
                    f13 = f18 * f1;
                    f15 = f16 * f3;
                    f16 = f21 + f19;
                    f17 = heapClassInst.heapFloat[r0 + numDefine12];
                    f6 = f6 + f22;
                    f18 = f20 * f5;
                    f0 = f0 + f2;
                    f2 = f7 * f4;
                    f1 = f12 * f1;
                    f3 = f10 * f3;
                    f4 = f9 + f11;
                    f7 = heapClassInst.heapFloat[r0 + numDefine13];
                    f9 = heapClassInst.heapFloat[r0 + numDefine14];
                    f10 = f13 + f15;
                    f11 = f14 * f5;
                    f12 = f16 + f17;
                    f6 = f6 + f18;
                    f0 = f0 + f2;
                    r0 = r1 >> numDefine2;
                    f1 = f1 + f3;
                    f2 = f8 * f5;
                    f3 = f4 + f7;
                    f4 = f10 + f11;
                    f5 = f12 - f6;
                    f0 = f0 + f9;
                    f1 = f1 + f2;
                    f2 = f3 - f4;
                    heapClassInst.heapFloat[r0] = (float)f5;
                    f5 = f0 - f1;
                    heapClassInst.heapFloat[r0 + 1] = (float)f2;
                    heapClassInst.heapFloat[r0 + numDefine2] = (float)f5;
                    r1 = r2 >> numDefine2;
                    f2 = f12 + f6;
                    heapClassInst.heap32[r0 + numDefine3] = 0;
                    f3 = f3 + f4;
                    heapClassInst.heapFloat[r1] = (float)f2;
                    f0 = f0 + f1;
                    heapClassInst.heapFloat[r1 + 1] = (float)f3;
                    heapClassInst.heapFloat[r1 + numDefine2] = (float)f0;
                    heapClassInst.heap32[r1 + numDefine3] = 0;
                    return;
                } else {
                    r0 = twoEStr5104;
                    r1 = twoEStr3102;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine199;
                    assertNew(i7);
                }
            } else {
                r0 = twoEStr4103;
                r1 = twoEStr3102;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine198;
                assertNew(i7);
            }
        } else {
            r0 = twoEStr2101;
            r1 = twoEStr3102;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine197;
            assertNew(i7);
        }
    }

    public static void  zn14btQuantizedBvh9buildTreeEii(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        double f10 = 0.0;
        double f11 = 0.0;
        double f12 = 0.0;
        double f13 = 0.0;
        double f14 = 0.0;
        double f15 = 0.0;
        double f16 = 0.0;
        double f17 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg112;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp + numDefine2];
        r2 = (r1 - r0) | 0;
        if (r2 > 0) {
            r3 = heapClassInst.heap32[fp];
            r4 = r3 >> numDefine2;
            r5 = heapClassInst.heap32[r4 + numDefine14];
            if (r2 != 1) {
                repeat5: do {
                    if (r0 < r1) {
                        r6 = heapClassInst.heapU8[r3 + numDefine60];
                        f1 = 0;
                        r7 = r0;
                        f2 = f1;
                        f3 = f1;
                        repeat7: while (true) {
                            r8 = r6 & numDefine255;
                            if (r8 == 0) {
                                r9 = heapClassInst.heap32[r4 + numDefine19];
                                r10 = r7 << numDefine6;
                                r9 = (r9 + r10) | 0;
                                r9 = r9 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r9];
                                f5 = heapClassInst.heapFloat[r9 + 1];
                                f8 = heapClassInst.heapFloat[r9 + numDefine2];
                                f4 = heapClassInst.heapFloat[r9 + numDefine4];
                                f6 = heapClassInst.heapFloat[r9 + numDefine5];
                                f7 = heapClassInst.heapFloat[r9 + numDefine6];
                            } else {
                                r9 = heapClassInst.heap32[r4 + numDefine29];
                                r10 = r7 << numDefine4;
                                r11 = (r9 + r10) | 0;
                                r9 = heapClassInst.heapU16[(r9 + r10) >> 1];
                                r10 = heapClassInst.heapU16[(r11 + numDefine2) >> 1];
                                r12 = heapClassInst.heapU16[(r11 + numDefine4) >> 1];
                                r13 = heapClassInst.heapU16[(r11 + numDefine6) >> 1];
                                r14 = heapClassInst.heapU16[(r11 + numDefine8) >> 1];
                                r11 = heapClassInst.heapU16[(r11 + numDefine10) >> 1];
                                f0 = uint(r9);
                                f4 = heapClassInst.heapFloat[r4 + numDefine9];
                                f5 = uint(r13);
                                f6 = uint(r10);
                                f7 = heapClassInst.heapFloat[r4 + numDefine10];
                                f8 = uint(r14);
                                f9 = uint(r12);
                                f10 = heapClassInst.heapFloat[r4 + numDefine11];
                                f11 = uint(r11);
                                f0 = f0 / f4;
                                f12 = heapClassInst.heapFloat[r4 + 1];
                                f4 = f5 / f4;
                                f5 = f6 / f7;
                                f6 = heapClassInst.heapFloat[r4 + numDefine2];
                                f7 = f8 / f7;
                                f8 = f9 / f10;
                                f9 = heapClassInst.heapFloat[r4 + numDefine3];
                                f10 = f11 / f10;
                                f0 = f0 + f12;
                                f5 = f5 + f6;
                                f8 = f8 + f9;
                                f4 = f4 + f12;
                                f6 = f7 + f6;
                                f7 = f10 + f9;
                            }
                            f0 = f4 + f0;
                            f4 = numDefineFloat05;
                            f5 = f6 + f5;
                            f6 = f7 + f8;
                            f0 = f0 * f4;
                            f5 = f5 * f4;
                            f6 = f6 * f4;
                            r7 = (r7 + 1) | 0;
                            f3 = f3 + f0;
                            f2 = f2 + f5;
                            f1 = f1 + f6;
                            if (!(r1 != r7)) {
                                break repeat7;
                            }
                        }
                        f0 = r2;
                        if (r0 < r1) {
                            f5 = 1;
                            f5 = f5 / f0;
                            f6 = f3 * f5;
                            f7 = f2 * f5;
                            f5 = f1 * f5;
                            f1 = 0;
                            r6 = r0;
                            f2 = f1;
                            f3 = f1;
                            while (true) {
                                if (r8 == 0) {
                                    r7 = heapClassInst.heap32[r4 + numDefine19];
                                    r9 = r6 << numDefine6;
                                    r7 = (r7 + r9) | 0;
                                    r7 = r7 >> numDefine2;
                                    f8 = heapClassInst.heapFloat[r7];
                                    f10 = heapClassInst.heapFloat[r7 + 1];
                                    f13 = heapClassInst.heapFloat[r7 + numDefine2];
                                    f9 = heapClassInst.heapFloat[r7 + numDefine4];
                                    f11 = heapClassInst.heapFloat[r7 + numDefine5];
                                    f12 = heapClassInst.heapFloat[r7 + numDefine6];
                                } else {
                                    r7 = heapClassInst.heap32[r4 + numDefine29];
                                    r9 = r6 << numDefine4;
                                    r10 = (r7 + r9) | 0;
                                    r7 = heapClassInst.heapU16[(r7 + r9) >> 1];
                                    r9 = heapClassInst.heapU16[(r10 + numDefine2) >> 1];
                                    r11 = heapClassInst.heapU16[(r10 + numDefine4) >> 1];
                                    r12 = heapClassInst.heapU16[(r10 + numDefine6) >> 1];
                                    r13 = heapClassInst.heapU16[(r10 + numDefine8) >> 1];
                                    r10 = heapClassInst.heapU16[(r10 + numDefine10) >> 1];
                                    f8 = uint(r7);
                                    f9 = heapClassInst.heapFloat[r4 + numDefine9];
                                    f10 = uint(r12);
                                    f11 = uint(r9);
                                    f12 = heapClassInst.heapFloat[r4 + numDefine10];
                                    f13 = uint(r13);
                                    f14 = uint(r11);
                                    f15 = heapClassInst.heapFloat[r4 + numDefine11];
                                    f16 = uint(r10);
                                    f8 = f8 / f9;
                                    f17 = heapClassInst.heapFloat[r4 + 1];
                                    f9 = f10 / f9;
                                    f10 = f11 / f12;
                                    f11 = heapClassInst.heapFloat[r4 + numDefine2];
                                    f12 = f13 / f12;
                                    f13 = f14 / f15;
                                    f14 = heapClassInst.heapFloat[r4 + numDefine3];
                                    f15 = f16 / f15;
                                    f8 = f8 + f17;
                                    f10 = f10 + f11;
                                    f13 = f13 + f14;
                                    f9 = f9 + f17;
                                    f11 = f12 + f11;
                                    f12 = f15 + f14;
                                }
                                f8 = f9 + f8;
                                f9 = f11 + f10;
                                f10 = f12 + f13;
                                f8 = f8 * f4;
                                f9 = f9 * f4;
                                f10 = f10 * f4;
                                f8 = f8 - f6;
                                f9 = f9 - f7;
                                f10 = f10 - f5;
                                f8 = f8 * f8;
                                f9 = f9 * f9;
                                f10 = f10 * f10;
                                r6 = (r6 + 1) | 0;
                                f3 = f3 + f8;
                                f2 = f2 + f9;
                                f1 = f1 + f10;
                                if (!(r1 != r6)) {
                                    break repeat5;
                                }
                            }
                        } else {
                            f1 = 0;
                            f2 = f1;
                            f3 = f1;
                        }
                    } else {
                        f0 = r2;
                        f1 = 0;
                        f2 = f1;
                        f3 = f1;
                    }
                } while (false);
                f4 = -1;
                f5 = 1;
                f0 = f0 + f4;
                f0 = f5 / f0;
                f3 = f3 * f0;
                f2 = f2 * f0;
                f0 = f1 * f0;
                if (f3 >= f2) {
                    r6 = numDefine2;
                    r7 = 0;
                    r6 = f3 < f0 ? r6 : r7;
                } else {
                    r6 = numDefine2;
                    r7 = 1;
                    r6 = f2 < f0 ? r6 : r7;
                }
                r7 = sp + numDefineNeg32;
                r8 = r7 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg8] = 0;
                heapClassInst.heap32[r8 + 1] = 0;
                heapClassInst.heap32[r8 + numDefine2] = 0;
                heapClassInst.heap32[r8 + numDefine3] = 0;
                if (r0 < r1) {
                    r9 = heapClassInst.heapU8[r3 + numDefine60];
                    f0 = 0;
                    r10 = r0;
                    f1 = f0;
                    f2 = f0;
                    repeat31: while (true) {
                        r11 = r9 & numDefine255;
                        if (r11 == 0) {
                            r11 = heapClassInst.heap32[r4 + numDefine19];
                            r12 = r10 << numDefine6;
                            r11 = (r11 + r12) | 0;
                            r11 = r11 >> numDefine2;
                            f3 = heapClassInst.heapFloat[r11];
                            f6 = heapClassInst.heapFloat[r11 + 1];
                            f9 = heapClassInst.heapFloat[r11 + numDefine2];
                            f4 = heapClassInst.heapFloat[r11 + numDefine4];
                            f7 = heapClassInst.heapFloat[r11 + numDefine5];
                            f8 = heapClassInst.heapFloat[r11 + numDefine6];
                        } else {
                            r11 = heapClassInst.heap32[r4 + numDefine29];
                            r12 = r10 << numDefine4;
                            r13 = (r11 + r12) | 0;
                            r11 = heapClassInst.heapU16[(r11 + r12) >> 1];
                            r12 = heapClassInst.heapU16[(r13 + numDefine2) >> 1];
                            r14 = heapClassInst.heapU16[(r13 + numDefine4) >> 1];
                            r15 = heapClassInst.heapU16[(r13 + numDefine6) >> 1];
                            r16 = heapClassInst.heapU16[(r13 + numDefine8) >> 1];
                            r13 = heapClassInst.heapU16[(r13 + numDefine10) >> 1];
                            f3 = uint(r11);
                            f4 = heapClassInst.heapFloat[r4 + numDefine9];
                            f6 = uint(r15);
                            f7 = uint(r12);
                            f8 = heapClassInst.heapFloat[r4 + numDefine10];
                            f9 = uint(r16);
                            f10 = uint(r14);
                            f11 = heapClassInst.heapFloat[r4 + numDefine11];
                            f12 = uint(r13);
                            f3 = f3 / f4;
                            f13 = heapClassInst.heapFloat[r4 + 1];
                            f4 = f6 / f4;
                            f6 = f7 / f8;
                            f7 = heapClassInst.heapFloat[r4 + numDefine2];
                            f8 = f9 / f8;
                            f9 = f10 / f11;
                            f10 = heapClassInst.heapFloat[r4 + numDefine3];
                            f11 = f12 / f11;
                            f3 = f3 + f13;
                            f6 = f6 + f7;
                            f9 = f9 + f10;
                            f4 = f4 + f13;
                            f7 = f8 + f7;
                            f8 = f11 + f10;
                        }
                        f3 = f4 + f3;
                        f4 = numDefineFloat05;
                        f6 = f7 + f6;
                        f7 = f8 + f9;
                        f3 = f3 * f4;
                        f6 = f6 * f4;
                        f4 = f7 * f4;
                        r10 = (r10 + 1) | 0;
                        f2 = f2 + f3;
                        f1 = f1 + f6;
                        f0 = f0 + f4;
                        if (!(r1 != r10)) {
                            break repeat31;
                        }
                    }
                    heapClassInst.heapFloat[r8 + numDefine2] = (float)f0;
                    heapClassInst.heapFloat[r8 + 1] = (float)f1;
                    heapClassInst.heapFloat[fp + numDefineNeg8] = (float)f2;
                } else {
                    f0 = 0;
                    f1 = f0;
                    f2 = f0;
                }
                f3 = r2;
                f3 = f5 / f3;
                f2 = f2 * f3;
                f1 = f1 * f3;
                heapClassInst.heapFloat[fp + numDefineNeg8] = (float)f2;
                f0 = f0 * f3;
                heapClassInst.heapFloat[r8 + 1] = (float)f1;
                heapClassInst.heapFloat[r8 + numDefine2] = (float)f0;
                repeat40: do {
                    if (r0 < r1) {
                        r8 = r6 << numDefine2;
                        r6 = (r7 + r8) | 0;
                        r6 = r6 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r6];
                        r6 = r0 << numDefine4;
                        r7 = (r0 - r1) | 0;
                        r9 = r0 << numDefine6;
                        r10 = r6 | numDefine12;
                        r11 = 0;
                        r12 = r9;
                        r6 = r0;
                        while (true) {
                            r13 = heapClassInst.heapU8[r3 + numDefine60];
                            if (r13 == 0) {
                                r14 = r11 << numDefine4;
                                r15 = heapClassInst.heap32[r4 + numDefine19];
                                r15 = (r15 + r9) | 0;
                                r14 = r14 << numDefine2;
                                r14 = (r15 - r14) | 0;
                                r14 = r14 >> numDefine2;
                                f1 = heapClassInst.heapFloat[r14];
                                f3 = heapClassInst.heapFloat[r14 + 1];
                                f6 = heapClassInst.heapFloat[r14 + numDefine2];
                                f2 = heapClassInst.heapFloat[r14 + numDefine4];
                                f4 = heapClassInst.heapFloat[r14 + numDefine5];
                                f5 = heapClassInst.heapFloat[r14 + numDefine6];
                            } else {
                                r14 = heapClassInst.heap32[r4 + numDefine29];
                                r14 = (r14 + r10) | 0;
                                r15 = r11 << numDefine4;
                                r14 = (r14 - r15) | 0;
                                r15 = heapClassInst.heapU16[(r14 + numDefineNeg12) >> 1];
                                r16 = heapClassInst.heapU16[(r14 + numDefineNeg10) >> 1];
                                r17 = heapClassInst.heapU16[(r14 + numDefineNeg8) >> 1];
                                r18 = heapClassInst.heapU16[(r14 + numDefineNeg6) >> 1];
                                r19 = heapClassInst.heapU16[(r14 + numDefineNeg4) >> 1];
                                r14 = heapClassInst.heapU16[(r14 + numDefineNeg2) >> 1];
                                f1 = uint(r15);
                                f2 = heapClassInst.heapFloat[r4 + numDefine9];
                                f3 = uint(r18);
                                f4 = uint(r16);
                                f5 = heapClassInst.heapFloat[r4 + numDefine10];
                                f6 = uint(r19);
                                f7 = uint(r17);
                                f8 = heapClassInst.heapFloat[r4 + numDefine11];
                                f9 = uint(r14);
                                f1 = f1 / f2;
                                f10 = heapClassInst.heapFloat[r4 + 1];
                                f2 = f3 / f2;
                                f3 = f4 / f5;
                                f4 = heapClassInst.heapFloat[r4 + numDefine2];
                                f5 = f6 / f5;
                                f6 = f7 / f8;
                                f7 = heapClassInst.heapFloat[r4 + numDefine3];
                                f8 = f9 / f8;
                                f1 = f1 + f10;
                                f3 = f3 + f4;
                                f6 = f6 + f7;
                                f2 = f2 + f10;
                                f4 = f5 + f4;
                                f5 = f8 + f7;
                            }
                            f1 = f2 + f1;
                            f2 = numDefineFloat05;
                            r14 = sp + numDefineNeg48;
                            f3 = f4 + f3;
                            f1 = f1 * f2;
                            f4 = f5 + f6;
                            r15 = r14 >> numDefine2;
                            f3 = f3 * f2;
                            heapClassInst.heapFloat[fp + numDefineNeg12] = (float)f1;
                            f1 = f4 * f2;
                            heapClassInst.heapFloat[r15 + 1] = (float)f3;
                            r14 = (r14 + r8) | 0;
                            heapClassInst.heapFloat[r15 + numDefine2] = (float)f1;
                            r14 = r14 >> numDefine2;
                            heapClassInst.heap32[r15 + numDefine3] = 0;
                            f1 = heapClassInst.heapFloat[r14];
                            if (f1 > f0) {
                                if (r13 == 0) {
                                    r13 = r11 << numDefine4;
                                    r14 = heapClassInst.heap32[r4 + numDefine19];
                                    r15 = (r14 + r9) | 0;
                                    r13 = r13 << numDefine2;
                                    r13 = (r15 - r13) | 0;
                                    r13 = r13 >> numDefine2;
                                    r15 = heapClassInst.heap32[r13 + numDefine15];
                                    r16 = heapClassInst.heap32[r13 + numDefine14];
                                    r17 = heapClassInst.heap32[r13 + numDefine13];
                                    r18 = heapClassInst.heap32[r13 + numDefine12];
                                    r19 = heapClassInst.heap32[r13 + numDefine11];
                                    r20 = heapClassInst.heap32[r13 + numDefine10];
                                    r21 = heapClassInst.heap32[r13 + numDefine9];
                                    r22 = heapClassInst.heap32[r13 + numDefine8];
                                    f1 = heapClassInst.heapFloat[r13 + numDefine7];
                                    f2 = heapClassInst.heapFloat[r13 + numDefine6];
                                    f3 = heapClassInst.heapFloat[r13 + numDefine5];
                                    f4 = heapClassInst.heapFloat[r13 + numDefine4];
                                    f5 = heapClassInst.heapFloat[r13 + numDefine3];
                                    f6 = heapClassInst.heapFloat[r13 + numDefine2];
                                    f7 = heapClassInst.heapFloat[r13 + 1];
                                    f8 = heapClassInst.heapFloat[r13];
                                    r13 = r6 << numDefine6;
                                    r23 = (r14 + r12) | 0;
                                    r14 = (r14 + r13) | 0;
                                    heapClassInst.heap32[g0] = r23;
                                    heapClassInst.heap32[g0 + 1] = r14;
                                    heapClassInst.heap32[g0 + numDefine2] = numDefine64;
                                    memcpy(i7);
                                    r14 = heapClassInst.heap32[r4 + numDefine19];
                                    r13 = (r14 + r13) | 0;
                                    r13 = r13 >> numDefine2;
                                    heapClassInst.heapFloat[r13] = (float)f8;
                                    heapClassInst.heapFloat[r13 + 1] = (float)f7;
                                    heapClassInst.heapFloat[r13 + numDefine2] = (float)f6;
                                    heapClassInst.heapFloat[r13 + numDefine3] = (float)f5;
                                    heapClassInst.heapFloat[r13 + numDefine4] = (float)f4;
                                    heapClassInst.heapFloat[r13 + numDefine5] = (float)f3;
                                    heapClassInst.heapFloat[r13 + numDefine6] = (float)f2;
                                    heapClassInst.heapFloat[r13 + numDefine7] = (float)f1;
                                    heapClassInst.heap32[r13 + numDefine8] = r22;
                                    heapClassInst.heap32[r13 + numDefine9] = r21;
                                    heapClassInst.heap32[r13 + numDefine10] = r20;
                                    heapClassInst.heap32[r13 + numDefine11] = r19;
                                    heapClassInst.heap32[r13 + numDefine12] = r18;
                                    heapClassInst.heap32[r13 + numDefine13] = r17;
                                    heapClassInst.heap32[r13 + numDefine14] = r16;
                                    heapClassInst.heap32[r13 + numDefine15] = r15;
                                } else {
                                    r13 = heapClassInst.heap32[r4 + numDefine29];
                                    r14 = (r13 + r10) | 0;
                                    r15 = r11 << numDefine4;
                                    r14 = (r14 - r15) | 0;
                                    r15 = r6 << numDefine4;
                                    r16 = r14 >> numDefine2;
                                    r17 = heapClassInst.heap32[r16];
                                    r18 = heapClassInst.heapU16[(r14 + numDefineNeg2) >> 1];
                                    r19 = heapClassInst.heapU16[(r14 + numDefineNeg4) >> 1];
                                    r20 = heapClassInst.heapU16[(r14 + numDefineNeg6) >> 1];
                                    r21 = heapClassInst.heapU16[(r14 + numDefineNeg8) >> 1];
                                    r22 = heapClassInst.heapU16[(r14 + numDefineNeg10) >> 1];
                                    r23 = heapClassInst.heapU16[(r13 + r15) >> 1];
                                    r24 = heapClassInst.heapU16[(r14 + numDefineNeg12) >> 1];
                                    r13 = (r13 + r15) | 0;
                                    heapClassInst.heap16[(r14 + numDefineNeg12) >> 1] = (short)r23;
                                    r23 = heapClassInst.heapU16[(r13 + numDefine2) >> 1];
                                    heapClassInst.heap16[(r14 + numDefineNeg10) >> 1] = (short)r23;
                                    r23 = heapClassInst.heapU16[(r13 + numDefine4) >> 1];
                                    heapClassInst.heap16[(r14 + numDefineNeg8) >> 1] = (short)r23;
                                    r23 = heapClassInst.heapU16[(r13 + numDefine6) >> 1];
                                    heapClassInst.heap16[(r14 + numDefineNeg6) >> 1] = (short)r23;
                                    r23 = heapClassInst.heapU16[(r13 + numDefine8) >> 1];
                                    heapClassInst.heap16[(r14 + numDefineNeg4) >> 1] = (short)r23;
                                    r23 = heapClassInst.heapU16[(r13 + numDefine10) >> 1];
                                    r13 = r13 >> numDefine2;
                                    heapClassInst.heap16[(r14 + numDefineNeg2) >> 1] = (short)r23;
                                    r13 = heapClassInst.heap32[r13 + numDefine3];
                                    heapClassInst.heap32[r16] = r13;
                                    r13 = heapClassInst.heap32[r4 + numDefine29];
                                    r14 = (r13 + r15) | 0;
                                    heapClassInst.heap16[(r13 + r15) >> 1] = (short)r24;
                                    heapClassInst.heap16[(r14 + numDefine2) >> 1] = (short)r22;
                                    heapClassInst.heap16[(r14 + numDefine4) >> 1] = (short)r21;
                                    heapClassInst.heap16[(r14 + numDefine6) >> 1] = (short)r20;
                                    heapClassInst.heap16[(r14 + numDefine8) >> 1] = (short)r19;
                                    r13 = r14 >> numDefine2;
                                    heapClassInst.heap16[(r14 + numDefine10) >> 1] = (short)r18;
                                    heapClassInst.heap32[r13 + numDefine3] = r17;
                                }
                                r6 = (r6 + 1) | 0;
                            }
                            r11 = (r11 + -1) | 0;
                            r12 = (r12 + numDefine64) | 0;
                            if (!(r7 != r11)) {
                                break repeat40;
                            }
                        }
                    } else {
                        r6 = r0;
                    }
                } while (false);
                r7 = (r2 / numDefine3) | 0;
                r8 = (r7 + r0) | 0;
                if (r8 >= r6) {
                    label = numDefine46;
                } else {
                    r8 = (r1 + -1) | 0;
                    r7 = (r8 - r7) | 0;
                    if (r7 <= r6) {
                        label = numDefine46;
                    } else {
                        label = numDefine47;
                    }
                }
                if (label == numDefine46) {
                    r6 = r2 >> 1;
                    r6 = (r6 + r0) | 0;
                }
                if (!(r6 == r0)) {
                    if (r6 != r1) {
                        r2 = heapClassInst.heap32[r4 + numDefine14];
                        heapClassInst.heap32[fp + numDefineNeg21] = r2;
                        r2 = heapClassInst.heapU8[r3 + numDefine60];
                        if (r2 == 0) {
                            r2 = heapClassInst.heap32[fp + numDefineNeg21];
                            r2 = r2 << numDefine6;
                            r7 = heapClassInst.heap32[r4 + numDefine24];
                            r2 = (r7 + r2) | 0;
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r2] = heapClassInst.heap32[r4 + numDefine5];
                            heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r4 + numDefine6];
                            heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                            heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
                        } else {
                            r2 = heapClassInst.heap32[r4 + numDefine34];
                            r7 = heapClassInst.heap32[fp + numDefineNeg21];
                            r7 = r7 << numDefine4;
                            r2 = (r2 + r7) | 0;
                            r7 = (r3 + numDefine20) | 0;
                            heapClassInst.heap32[g0] = r3;
                            heapClassInst.heap32[g0 + 1] = r2;
                            heapClassInst.heap32[g0 + numDefine2] = r7;
                            heapClassInst.heap32[g0 + numDefine3] = 0;
                            znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                        }
                        r2 = heapClassInst.heap32[r4 + numDefine14];
                        r7 = heapClassInst.heapU8[r3 + numDefine60];
                        if (r7 == 0) {
                            r2 = r2 << numDefine6;
                            r7 = heapClassInst.heap32[r4 + numDefine24];
                            r2 = (r7 + r2) | 0;
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r4 + 1];
                            heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r4 + numDefine5];
                            heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r4 + numDefine6];
                            heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r4 + numDefine7];
                        } else {
                            r7 = heapClassInst.heap32[r4 + numDefine34];
                            r2 = r2 << numDefine4;
                            r2 = (r7 + r2) | 0;
                            r2 = (r2 + numDefine6) | 0;
                            r7 = (r3 + numDefine4) | 0;
                            heapClassInst.heap32[g0] = r3;
                            heapClassInst.heap32[g0 + 1] = r2;
                            heapClassInst.heap32[g0 + numDefine2] = r7;
                            heapClassInst.heap32[g0 + numDefine3] = 1;
                            znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                        }
                        repeat73: do {
                            if (!(r0 >= r1)) {
                                r2 = r0;
                                while (true) {
                                    r7 = heapClassInst.heapU8[r3 + numDefine60];
                                    repeat77: do {
                                        if (r7 == 0) {
                                            r7 = heapClassInst.heap32[r4 + numDefine19];
                                            r8 = r2 << numDefine6;
                                            r7 = (r7 + r8) | 0;
                                            r7 = r7 >> numDefine2;
                                            f0 = heapClassInst.heapFloat[r7 + numDefine4];
                                            r8 = sp + numDefineNeg80;
                                            heapClassInst.heapFloat[fp + numDefineNeg20] = (float)f0;
                                            f1 = heapClassInst.heapFloat[r7 + numDefine5];
                                            r8 = r8 >> numDefine2;
                                            heapClassInst.heapFloat[r8 + 1] = (float)f1;
                                            f2 = heapClassInst.heapFloat[r7 + numDefine6];
                                            heapClassInst.heapFloat[r8 + numDefine2] = (float)f2;
                                            f3 = heapClassInst.heapFloat[r7 + numDefine7];
                                            heapClassInst.heapFloat[r8 + numDefine3] = (float)f3;
                                            f4 = heapClassInst.heapFloat[r7];
                                            r8 = sp + numDefineNeg64;
                                            heapClassInst.heapFloat[fp + numDefineNeg16] = (float)f4;
                                            f5 = heapClassInst.heapFloat[r7 + 1];
                                            r8 = r8 >> numDefine2;
                                            heapClassInst.heapFloat[r8 + 1] = (float)f5;
                                            f6 = heapClassInst.heapFloat[r7 + numDefine2];
                                            heapClassInst.heapFloat[r8 + numDefine2] = (float)f6;
                                            f7 = heapClassInst.heapFloat[r7 + numDefine3];
                                            heapClassInst.heapFloat[r8 + numDefine3] = (float)f7;
                                            r7 = heapClassInst.heap32[r4 + numDefine14];
                                            r8 = heapClassInst.heap32[r4 + numDefine24];
                                            r7 = r7 << numDefine6;
                                            r8 = (r8 + r7) | 0;
                                            r8 = r8 >> numDefine2;
                                            f8 = heapClassInst.heapFloat[r8];
                                            if (!(f4 >= f8)) {
                                                heapClassInst.heapFloat[r8] = (float)f4;
                                            }
                                            f4 = heapClassInst.heapFloat[r8 + 1];
                                            if (!(f5 >= f4)) {
                                                heapClassInst.heapFloat[r8 + 1] = (float)f5;
                                            }
                                            f4 = heapClassInst.heapFloat[r8 + numDefine2];
                                            if (!(f6 >= f4)) {
                                                heapClassInst.heapFloat[r8 + numDefine2] = (float)f6;
                                            }
                                            f4 = heapClassInst.heapFloat[r8 + numDefine3];
                                            if (!(f7 >= f4)) {
                                                heapClassInst.heapFloat[r8 + numDefine3] = (float)f7;
                                            }
                                            r8 = heapClassInst.heap32[r4 + numDefine24];
                                            r7 = (r8 + r7) | 0;
                                            r7 = r7 >> numDefine2;
                                            f4 = heapClassInst.heapFloat[r7 + numDefine4];
                                            if (!(f4 >= f0)) {
                                                heapClassInst.heapFloat[r7 + numDefine4] = (float)f0;
                                            }
                                            f0 = heapClassInst.heapFloat[r7 + numDefine5];
                                            if (!(f0 >= f1)) {
                                                heapClassInst.heapFloat[r7 + numDefine5] = (float)f1;
                                            }
                                            f0 = heapClassInst.heapFloat[r7 + numDefine6];
                                            if (!(f0 >= f2)) {
                                                heapClassInst.heapFloat[r7 + numDefine6] = (float)f2;
                                            }
                                            f0 = heapClassInst.heapFloat[r7 + numDefine7];
                                            if (f0 >= f3) {
                                                break repeat77;
                                            } else {
                                                heapClassInst.heapFloat[r7 + numDefine7] = (float)f3;
                                            }
                                        } else {
                                            r7 = heapClassInst.heap32[r4 + numDefine29];
                                            r8 = r2 << numDefine4;
                                            r9 = (r7 + r8) | 0;
                                            r10 = sp + numDefineNeg80;
                                            r11 = heapClassInst.heapU16[(r9 + numDefine10) >> 1];
                                            r12 = heapClassInst.heapU16[(r9 + numDefine8) >> 1];
                                            r13 = heapClassInst.heapU16[(r9 + numDefine6) >> 1];
                                            f0 = heapClassInst.heapFloat[r4 + numDefine11];
                                            f1 = heapClassInst.heapFloat[r4 + numDefine10];
                                            f2 = heapClassInst.heapFloat[r4 + numDefine9];
                                            r14 = r10 >> numDefine2;
                                            f3 = uint(r13);
                                            heapClassInst.heap32[r14 + numDefine3] = 0;
                                            f3 = f3 / f2;
                                            f4 = heapClassInst.heapFloat[r4 + 1];
                                            f3 = f3 + f4;
                                            f5 = uint(r12);
                                            heapClassInst.heapFloat[fp + numDefineNeg20] = (float)f3;
                                            f3 = f5 / f1;
                                            f5 = heapClassInst.heapFloat[r4 + numDefine2];
                                            f3 = f3 + f5;
                                            f6 = uint(r11);
                                            heapClassInst.heapFloat[r14 + 1] = (float)f3;
                                            f3 = f6 / f0;
                                            f6 = heapClassInst.heapFloat[r4 + numDefine3];
                                            f3 = f3 + f6;
                                            heapClassInst.heapFloat[r14 + numDefine2] = (float)f3;
                                            r7 = heapClassInst.heapU16[(r7 + r8) >> 1];
                                            r8 = sp + numDefineNeg64;
                                            f3 = uint(r7);
                                            r7 = heapClassInst.heapU16[(r9 + numDefine4) >> 1];
                                            r9 = heapClassInst.heapU16[(r9 + numDefine2) >> 1];
                                            f7 = uint(r9);
                                            f2 = f3 / f2;
                                            r9 = r8 >> numDefine2;
                                            f3 = uint(r7);
                                            f1 = f7 / f1;
                                            f2 = f2 + f4;
                                            heapClassInst.heap32[r9 + numDefine3] = 0;
                                            f0 = f3 / f0;
                                            f1 = f1 + f5;
                                            heapClassInst.heapFloat[fp + numDefineNeg16] = (float)f2;
                                            f0 = f0 + f6;
                                            heapClassInst.heapFloat[r9 + 1] = (float)f1;
                                            heapClassInst.heapFloat[r9 + numDefine2] = (float)f0;
                                            r7 = heapClassInst.heap32[r4 + numDefine14];
                                            r9 = sp + numDefineNeg6;
                                            heapClassInst.heap32[g0] = r3;
                                            heapClassInst.heap32[g0 + 1] = r9;
                                            heapClassInst.heap32[g0 + numDefine2] = r8;
                                            heapClassInst.heap32[g0 + numDefine3] = 0;
                                            znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                                            r8 = sp + numDefineNeg12;
                                            heapClassInst.heap32[g0] = r3;
                                            heapClassInst.heap32[g0 + 1] = r8;
                                            heapClassInst.heap32[g0 + numDefine2] = r10;
                                            heapClassInst.heap32[g0 + numDefine3] = 1;
                                            znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
                                            r8 = heapClassInst.heapU16[(sp + numDefineNeg6) >> 1];
                                            r9 = heapClassInst.heap32[r4 + numDefine34];
                                            r7 = r7 << numDefine4;
                                            r10 = heapClassInst.heapU16[(r9 + r7) >> 1];
                                            if (uint(r10) > uint(r8)) {
                                                heapClassInst.heap16[(r9 + r7) >> 1] = (short)r8;
                                                r9 = heapClassInst.heap32[r4 + numDefine34];
                                            }
                                            r8 = (r9 + r7) | 0;
                                            r10 = heapClassInst.heapU16[(sp + numDefineNeg12) >> 1];
                                            r11 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                                            if (uint(r11) < uint(r10)) {
                                                heapClassInst.heap16[(r8 + numDefine6) >> 1] = (short)r10;
                                                r9 = heapClassInst.heap32[r4 + numDefine34];
                                            }
                                            r8 = (r9 + r7) | 0;
                                            r10 = heapClassInst.heapU16[(sp + numDefineNeg4) >> 1];
                                            r11 = heapClassInst.heapU16[(r8 + numDefine2) >> 1];
                                            if (uint(r11) > uint(r10)) {
                                                heapClassInst.heap16[(r8 + numDefine2) >> 1] = (short)r10;
                                                r9 = heapClassInst.heap32[r4 + numDefine34];
                                            }
                                            r8 = (r9 + r7) | 0;
                                            r10 = heapClassInst.heapU16[(sp + numDefineNeg10) >> 1];
                                            r11 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                                            if (uint(r11) < uint(r10)) {
                                                heapClassInst.heap16[(r8 + numDefine8) >> 1] = (short)r10;
                                                r9 = heapClassInst.heap32[r4 + numDefine34];
                                            }
                                            r8 = (r9 + r7) | 0;
                                            r10 = heapClassInst.heapU16[(sp + numDefineNeg2) >> 1];
                                            r11 = heapClassInst.heapU16[(r8 + numDefine4) >> 1];
                                            if (uint(r11) > uint(r10)) {
                                                heapClassInst.heap16[(r8 + numDefine4) >> 1] = (short)r10;
                                                r9 = heapClassInst.heap32[r4 + numDefine34];
                                            }
                                            r7 = (r9 + r7) | 0;
                                            r8 = heapClassInst.heapU16[(sp + numDefineNeg8) >> 1];
                                            r9 = heapClassInst.heapU16[(r7 + numDefine10) >> 1];
                                            if (uint(r9) < uint(r8)) {
                                                heapClassInst.heap16[(r7 + numDefine10) >> 1] = (short)r8;
                                            }
                                        }
                                    } while (false);
                                    r2 = (r2 + 1) | 0;
                                    if (!(r1 != r2)) {
                                        break repeat73;
                                    }
                                }
                            }
                        } while (false);
                        r2 = heapClassInst.heap32[r4 + numDefine14];
                        r7 = (r2 + 1) | 0;
                        heapClassInst.heap32[r4 + numDefine14] = r7;
                        heapClassInst.heap32[g0] = r3;
                        heapClassInst.heap32[g0 + 1] = r0;
                        heapClassInst.heap32[g0 + numDefine2] = r6;
                        zn14btQuantizedBvh9buildTreeEii(i7);
                        r0 = heapClassInst.heap32[r4 + numDefine14];
                        heapClassInst.heap32[fp + numDefineNeg23] = r0;
                        heapClassInst.heap32[g0] = r3;
                        heapClassInst.heap32[g0 + 1] = r6;
                        heapClassInst.heap32[g0 + numDefine2] = r1;
                        zn14btQuantizedBvh9buildTreeEii(i7);
                        r0 = heapClassInst.heap32[r4 + numDefine14];
                        r0 = (r0 - r5) | 0;
                        heapClassInst.heap32[fp + numDefineNeg22] = r0;
                        r0 = heapClassInst.heapU8[r3 + numDefine60];
                        repeat120: do {
                            if (!(r0 == 0)) {
                                r0 = heapClassInst.heap32[fp + numDefineNeg22];
                                r0 = r0 << numDefine4;
                                if (!(r0 < numDefine2049)) {
                                    r0 = heapClassInst.heap32[r4 + numDefine34];
                                    r1 = heapClassInst.heap32[fp + numDefineNeg23];
                                    r1 = r1 << numDefine4;
                                    heapClassInst.heap32[fp + numDefineNeg24] = r1;
                                    r2 = r2 << numDefine4;
                                    r1 = (r0 + r1) | 0;
                                    r2 = (r0 + r2) | 0;
                                    r5 = r1 >> numDefine2;
                                    r6 = r2 >> numDefine2;
                                    r5 = heapClassInst.heap32[r5 + numDefine3];
                                    r8 = 0;
                                    r6 = heapClassInst.heap32[r6 + numDefine7];
                                    r9 = 1;
                                    r10 = (r8 - r6) | 0;
                                    r6 = r6 < 0 ? r10 : r9;
                                    r10 = r6 << numDefine4;
                                    if (!(r10 > numDefine2048)) {
                                        r10 = heapClassInst.heap32[r4 + numDefine39];
                                        r11 = heapClassInst.heap32[r4 + numDefine38];
                                        if (r10 == r11) {
                                            r12 = r11 << 1;
                                            r12 = r11 == 0 ? r9 : r12;
                                            if (r10 >= r12) {
                                                label = numDefine92;
                                            } else {
                                                if (r12 != 0) {
                                                    r10 = gNumAlignedAllocs;
                                                    r10 = r10 >> numDefine2;
                                                    r13 = heapClassInst.heap32[r10];
                                                    r13 = (r13 + 1) | 0;
                                                    r14 = r12 << numDefine5;
                                                    heapClassInst.heap32[r10] = r13;
                                                    r10 = r14 | numDefine19;
                                                    heapClassInst.heap32[g0] = r10;
                                                    mallocNew(i7);
                                                    r13 = commonVariable.rg0;
                                                    if (r13 != 0) {
                                                        r10 = 0;
                                                        r14 = (r13 + numDefine4) | 0;
                                                        r10 = (r10 - r14) | 0;
                                                        r10 = r10 & numDefine15;
                                                        r10 = (r13 + r10) | 0;
                                                        r14 = (r10 + numDefine4) | 0;
                                                        r10 = r10 >> numDefine2;
                                                        heapClassInst.heap32[r10] = r13;
                                                        r13 = r14;
                                                    }
                                                } else {
                                                    r13 = 0;
                                                }
                                                r14 = (r3 + numDefine160) | 0;
                                                if (r11 < 1) {
                                                    r10 = r14 >> numDefine2;
                                                    r16 = heapClassInst.heap32[r10];
                                                } else {
                                                    r10 = 0;
                                                    r15 = r11;
                                                    repeat137: while (true) {
                                                        r16 = r14 >> numDefine2;
                                                        r16 = heapClassInst.heap32[r16];
                                                        r17 = (r16 + r10) | 0;
                                                        r17 = r17 >> numDefine2;
                                                        r18 = (r13 + r10) | 0;
                                                        r15 = (r15 + -1) | 0;
                                                        r10 = (r10 + numDefine32) | 0;
                                                        r19 = heapClassInst.heap32[r17];
                                                        r18 = r18 >> numDefine2;
                                                        r20 = heapClassInst.heap32[r17 + 1];
                                                        r21 = heapClassInst.heap32[r17 + numDefine2];
                                                        r22 = heapClassInst.heap32[r17 + numDefine3];
                                                        r23 = heapClassInst.heap32[r17 + numDefine4];
                                                        r24 = heapClassInst.heap32[r17 + numDefine5];
                                                        r25 = heapClassInst.heap32[r17 + numDefine6];
                                                        r17 = heapClassInst.heap32[r17 + numDefine7];
                                                        heapClassInst.heap32[r18] = r19;
                                                        heapClassInst.heap32[r18 + 1] = r20;
                                                        heapClassInst.heap32[r18 + numDefine2] = r21;
                                                        heapClassInst.heap32[r18 + numDefine3] = r22;
                                                        heapClassInst.heap32[r18 + numDefine4] = r23;
                                                        heapClassInst.heap32[r18 + numDefine5] = r24;
                                                        heapClassInst.heap32[r18 + numDefine6] = r25;
                                                        heapClassInst.heap32[r18 + numDefine7] = r17;
                                                        if (!(r15 != 0)) {
                                                            break repeat137;
                                                        }
                                                    }
                                                    r14 = (r3 + numDefine160) | 0;
                                                }
                                                if (r16 != 0) {
                                                    r10 = heapClassInst.heapU8[r3 + numDefine164];
                                                    if (r10 != 0) {
                                                        r10 = gNumAlignedFree;
                                                        r10 = r10 >> numDefine2;
                                                        r15 = heapClassInst.heap32[r10];
                                                        r15 = (r15 + 1) | 0;
                                                        r16 = r16 >> numDefine2;
                                                        heapClassInst.heap32[r10] = r15;
                                                        r10 = heapClassInst.heap32[r16 + -1];
                                                        heapClassInst.heap32[g0] = r10;
                                                        free(i7);
                                                        r10 = heapClassInst.heap32[r4 + numDefine38];
                                                    } else {
                                                        r10 = r11;
                                                    }
                                                    r15 = r14 >> numDefine2;
                                                    heapClassInst.heap32[r15] = 0;
                                                } else {
                                                    r10 = r11;
                                                }
                                                r14 = r14 >> numDefine2;
                                                heapClassInst.heap8[r3 + numDefine164] = (byte)r9;
                                                heapClassInst.heap32[r14] = r13;
                                                heapClassInst.heap32[r4 + numDefine39] = r12;
                                                label = numDefine110;
                                            }
                                        } else {
                                            label = numDefine92;
                                        }
                                        if (label == numDefine92) {
                                            r10 = r11;
                                        }
                                        r10 = (r10 + 1) | 0;
                                        heapClassInst.heap32[r4 + numDefine38] = r10;
                                        r10 = heapClassInst.heap32[r4 + numDefine40];
                                        r12 = heapClassInst.heapU16[(r2 + numDefine16) >> 1];
                                        r11 = r11 << numDefine5;
                                        heapClassInst.heap16[(r10 + r11) >> 1] = (short)r12;
                                        r10 = (r10 + r11) | 0;
                                        r11 = heapClassInst.heapU16[(r2 + numDefine18) >> 1];
                                        heapClassInst.heap16[(r10 + numDefine2) >> 1] = (short)r11;
                                        r11 = heapClassInst.heapU16[(r2 + numDefine20) >> 1];
                                        heapClassInst.heap16[(r10 + numDefine4) >> 1] = (short)r11;
                                        r11 = heapClassInst.heapU16[(r2 + numDefine22) >> 1];
                                        heapClassInst.heap16[(r10 + numDefine6) >> 1] = (short)r11;
                                        r11 = heapClassInst.heapU16[(r2 + numDefine24) >> 1];
                                        heapClassInst.heap16[(r10 + numDefine8) >> 1] = (short)r11;
                                        r2 = heapClassInst.heapU16[(r2 + numDefine26) >> 1];
                                        r11 = r10 >> numDefine2;
                                        heapClassInst.heap16[(r10 + numDefine10) >> 1] = (short)r2;
                                        heapClassInst.heap32[r11 + numDefine3] = r7;
                                        heapClassInst.heap32[r11 + numDefine4] = r6;
                                    }
                                    r2 = (r8 - r5) | 0;
                                    r2 = r5 < 0 ? r2 : r9;
                                    r5 = r2 << numDefine4;
                                    if (!(r5 > numDefine2048)) {
                                        r5 = heapClassInst.heap32[r4 + numDefine39];
                                        r6 = heapClassInst.heap32[r4 + numDefine38];
                                        if (r5 == r6) {
                                            r7 = r6 << 1;
                                            r7 = r6 == 0 ? r9 : r7;
                                            if (r5 >= r7) {
                                                label = numDefine113;
                                            } else {
                                                if (r7 != 0) {
                                                    r5 = gNumAlignedAllocs;
                                                    r5 = r5 >> numDefine2;
                                                    r10 = heapClassInst.heap32[r5];
                                                    r10 = (r10 + 1) | 0;
                                                    r11 = r7 << numDefine5;
                                                    heapClassInst.heap32[r5] = r10;
                                                    r5 = r11 | numDefine19;
                                                    heapClassInst.heap32[g0] = r5;
                                                    mallocNew(i7);
                                                    r10 = commonVariable.rg0;
                                                    if (r10 != 0) {
                                                        r5 = (r10 + numDefine4) | 0;
                                                        r5 = (r8 - r5) | 0;
                                                        r5 = r5 & numDefine15;
                                                        r5 = (r10 + r5) | 0;
                                                        r11 = (r5 + numDefine4) | 0;
                                                        r5 = r5 >> numDefine2;
                                                        heapClassInst.heap32[r5] = r10;
                                                        r10 = r11;
                                                    }
                                                } else {
                                                    r10 = 0;
                                                }
                                                r11 = (r3 + numDefine160) | 0;
                                                if (r6 < 1) {
                                                    r5 = r11 >> numDefine2;
                                                    r12 = heapClassInst.heap32[r5];
                                                } else {
                                                    r5 = r6;
                                                    repeat166: while (true) {
                                                        r12 = r11 >> numDefine2;
                                                        r12 = heapClassInst.heap32[r12];
                                                        r13 = (r12 + r8) | 0;
                                                        r13 = r13 >> numDefine2;
                                                        r14 = (r10 + r8) | 0;
                                                        r5 = (r5 + -1) | 0;
                                                        r8 = (r8 + numDefine32) | 0;
                                                        r15 = heapClassInst.heap32[r13];
                                                        r14 = r14 >> numDefine2;
                                                        r16 = heapClassInst.heap32[r13 + 1];
                                                        r17 = heapClassInst.heap32[r13 + numDefine2];
                                                        r18 = heapClassInst.heap32[r13 + numDefine3];
                                                        r19 = heapClassInst.heap32[r13 + numDefine4];
                                                        r20 = heapClassInst.heap32[r13 + numDefine5];
                                                        r21 = heapClassInst.heap32[r13 + numDefine6];
                                                        r13 = heapClassInst.heap32[r13 + numDefine7];
                                                        heapClassInst.heap32[r14] = r15;
                                                        heapClassInst.heap32[r14 + 1] = r16;
                                                        heapClassInst.heap32[r14 + numDefine2] = r17;
                                                        heapClassInst.heap32[r14 + numDefine3] = r18;
                                                        heapClassInst.heap32[r14 + numDefine4] = r19;
                                                        heapClassInst.heap32[r14 + numDefine5] = r20;
                                                        heapClassInst.heap32[r14 + numDefine6] = r21;
                                                        heapClassInst.heap32[r14 + numDefine7] = r13;
                                                        if (!(r5 != 0)) {
                                                            break repeat166;
                                                        }
                                                    }
                                                    r11 = (r3 + numDefine160) | 0;
                                                }
                                                if (r12 != 0) {
                                                    r5 = heapClassInst.heapU8[r3 + numDefine164];
                                                    if (r5 != 0) {
                                                        r5 = gNumAlignedFree;
                                                        r5 = r5 >> numDefine2;
                                                        r8 = heapClassInst.heap32[r5];
                                                        r8 = (r8 + 1) | 0;
                                                        r12 = r12 >> numDefine2;
                                                        heapClassInst.heap32[r5] = r8;
                                                        r5 = heapClassInst.heap32[r12 + -1];
                                                        heapClassInst.heap32[g0] = r5;
                                                        free(i7);
                                                        r5 = heapClassInst.heap32[r4 + numDefine38];
                                                    } else {
                                                        r5 = r6;
                                                    }
                                                    r8 = r11 >> numDefine2;
                                                    heapClassInst.heap32[r8] = 0;
                                                } else {
                                                    r5 = r6;
                                                }
                                                r8 = r11 >> numDefine2;
                                                heapClassInst.heap8[r3 + numDefine164] = (byte)r9;
                                                heapClassInst.heap32[r8] = r10;
                                                heapClassInst.heap32[r4 + numDefine39] = r7;
                                                label = numDefine131;
                                            }
                                        } else {
                                            label = numDefine113;
                                        }
                                        if (label == numDefine113) {
                                            r5 = r6;
                                        }
                                        r5 = (r5 + 1) | 0;
                                        heapClassInst.heap32[r4 + numDefine38] = r5;
                                        r5 = heapClassInst.heap32[r4 + numDefine40];
                                        r7 = heapClassInst.heap32[fp + numDefineNeg24];
                                        r0 = heapClassInst.heapU16[(r0 + r7) >> 1];
                                        r6 = r6 << numDefine5;
                                        heapClassInst.heap16[(r5 + r6) >> 1] = (short)r0;
                                        r0 = (r5 + r6) | 0;
                                        r5 = heapClassInst.heapU16[(r1 + numDefine2) >> 1];
                                        heapClassInst.heap16[(r0 + numDefine2) >> 1] = (short)r5;
                                        r5 = heapClassInst.heapU16[(r1 + numDefine4) >> 1];
                                        heapClassInst.heap16[(r0 + numDefine4) >> 1] = (short)r5;
                                        r5 = heapClassInst.heapU16[(r1 + numDefine6) >> 1];
                                        heapClassInst.heap16[(r0 + numDefine6) >> 1] = (short)r5;
                                        r5 = heapClassInst.heapU16[(r1 + numDefine8) >> 1];
                                        heapClassInst.heap16[(r0 + numDefine8) >> 1] = (short)r5;
                                        r1 = heapClassInst.heapU16[(r1 + numDefine10) >> 1];
                                        r5 = r0 >> numDefine2;
                                        heapClassInst.heap16[(r0 + numDefine10) >> 1] = (short)r1;
                                        r0 = heapClassInst.heap32[fp + numDefineNeg23];
                                        heapClassInst.heap32[r5 + numDefine3] = r0;
                                        heapClassInst.heap32[r5 + numDefine4] = r2;
                                    }
                                    r0 = heapClassInst.heap32[r4 + numDefine38];
                                    heapClassInst.heap32[r4 + numDefine42] = r0;
                                    r0 = heapClassInst.heapU8[r3 + numDefine60];
                                    if (r0 == 0) {
                                        break repeat120;
                                    }
                                }
                                r0 = heapClassInst.heap32[fp + numDefineNeg21];
                                r0 = r0 << numDefine4;
                                r4 = heapClassInst.heap32[r4 + numDefine34];
                                r4 = (r4 + r0) | 0;
                                r0 = 0;
                                r4 = r4 >> numDefine2;
                                r1 = heapClassInst.heap32[fp + numDefineNeg22];
                                r0 = (r0 - r1) | 0;
                                heapClassInst.heap32[r4 + numDefine3] = r0;
                                return;
                            }
                        } while (false);
                        r0 = heapClassInst.heap32[fp + numDefineNeg21];
                        r0 = r0 << numDefine6;
                        r1 = heapClassInst.heap32[r4 + numDefine24];
                        r0 = (r1 + r0) | 0;
                        r0 = r0 >> numDefine2;
                        r1 = heapClassInst.heap32[fp + numDefineNeg22];
                        heapClassInst.heap32[r0 + numDefine8] = r1;
                        return;
                    }
                }
                r0 = twoEStr21;
                r1 = twoEStr537;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine278;
                assertNew(i7);
            } else {
                r1 = heapClassInst.heapU8[r3 + numDefine60];
                if (r1 == 0) {
                    r1 = heapClassInst.heap32[r4 + numDefine24];
                    r2 = heapClassInst.heap32[r4 + numDefine19];
                    r3 = r5 << numDefine6;
                    r0 = r0 << numDefine6;
                    r1 = (r1 + r3) | 0;
                    r0 = (r2 + r0) | 0;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = r0;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine64;
                    memcpy(i7);
                } else {
                    r0 = r0 << numDefine4;
                    r1 = heapClassInst.heap32[r4 + numDefine29];
                    r2 = heapClassInst.heap32[r4 + numDefine34];
                    r3 = heapClassInst.heapU16[(r1 + r0) >> 1];
                    r5 = r5 << numDefine4;
                    r0 = (r1 + r0) | 0;
                    heapClassInst.heap16[(r2 + r5) >> 1] = (short)r3;
                    r1 = (r2 + r5) | 0;
                    r2 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
                    heapClassInst.heap16[(r1 + numDefine2) >> 1] = (short)r2;
                    r2 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                    heapClassInst.heap16[(r1 + numDefine4) >> 1] = (short)r2;
                    r2 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
                    heapClassInst.heap16[(r1 + numDefine6) >> 1] = (short)r2;
                    r2 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
                    heapClassInst.heap16[(r1 + numDefine8) >> 1] = (short)r2;
                    r2 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap16[(r1 + numDefine10) >> 1] = (short)r2;
                    r1 = r1 >> numDefine2;
                    r0 = heapClassInst.heap32[r0 + numDefine3];
                    heapClassInst.heap32[r1 + numDefine3] = r0;
                }
                r0 = heapClassInst.heap32[r4 + numDefine14];
                r0 = (r0 + 1) | 0;
                heapClassInst.heap32[r4 + numDefine14] = r0;
                return;
            }
        } else {
            r0 = twoEStr2246;
            r1 = twoEStr537;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine127;
            assertNew(i7);
        }
    }

    public static void  zn14btQuantizedBvhD2Ev(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv14btQuantizedBvh;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine40];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine164];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine40] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine164] = (byte)r1;
        heapClassInst.heap32[r2 + numDefine40] = 0;
        heapClassInst.heap32[r2 + numDefine38] = 0;
        heapClassInst.heap32[r2 + numDefine39] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine34];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine140];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine34] = 0;
        }
        heapClassInst.heap8[r0 + numDefine140] = (byte)r1;
        heapClassInst.heap32[r2 + numDefine34] = 0;
        heapClassInst.heap32[r2 + numDefine32] = 0;
        heapClassInst.heap32[r2 + numDefine33] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine29];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine120];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine29] = 0;
        }
        heapClassInst.heap8[r0 + numDefine120] = (byte)r1;
        heapClassInst.heap32[r2 + numDefine29] = 0;
        heapClassInst.heap32[r2 + numDefine27] = 0;
        heapClassInst.heap32[r2 + numDefine28] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine24];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine100];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine24] = 0;
        }
        heapClassInst.heap8[r0 + numDefine100] = (byte)r1;
        heapClassInst.heap32[r2 + numDefine24] = 0;
        heapClassInst.heap32[r2 + numDefine22] = 0;
        heapClassInst.heap32[r2 + numDefine23] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine19];
        if (!(r3 == 0)) {
            r4 = heapClassInst.heapU8[r0 + numDefine80];
            if (!(r4 == 0)) {
                r4 = gNumAlignedFree;
                r4 = r4 >> numDefine2;
                r5 = heapClassInst.heap32[r4];
                r5 = (r5 + 1) | 0;
                r3 = r3 >> numDefine2;
                heapClassInst.heap32[r4] = r5;
                r3 = heapClassInst.heap32[r3 + -1];
                heapClassInst.heap32[g0] = r3;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine19] = 0;
        }
        heapClassInst.heap8[r0 + numDefine80] = (byte)r1;
        heapClassInst.heap32[r2 + numDefine19] = 0;
        heapClassInst.heap32[r2 + numDefine17] = 0;
        heapClassInst.heap32[r2 + numDefine18] = 0;
        return;
    }

    public static void zn28btCompoundCollisionAlgorithm26preallocateChildAlgorithmsEP17btCollisionObjectS1(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine28];
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = r1 == 0 ? r2 : r3;
        r5 = r4 >> numDefine2;
        r6 = heapClassInst.heap32[r5 + numDefine48];
        r6 = r6 >> numDefine2;
        r7 = heapClassInst.heap32[r6 + 1];
        if (r7 == numDefine31) {
            r7 = r0 >> numDefine2;
            r8 = heapClassInst.heap32[r7 + numDefine3];
            r9 = heapClassInst.heap32[r6 + numDefine4];
            repeat3: do {
                if (!(r8 > r9)) {
                    if (!(r8 >= r9)) {
                        r10 = heapClassInst.heap32[r7 + numDefine4];
                        if (!(r10 >= r9)) {
                            if (r9 != 0) {
                                r10 = gNumAlignedAllocs;
                                r10 = r10 >> numDefine2;
                                r11 = heapClassInst.heap32[r10];
                                r12 = r9 << numDefine2;
                                r11 = (r11 + 1) | 0;
                                r12 = r12 | numDefine3;
                                heapClassInst.heap32[r10] = r11;
                                r10 = (r12 + numDefine16) | 0;
                                heapClassInst.heap32[g0] = r10;
                                mallocNew(i7);
                                r10 = commonVariable.rg0;
                                if (r10 != 0) {
                                    r11 = 0;
                                    r12 = (r10 + numDefine4) | 0;
                                    r11 = (r11 - r12) | 0;
                                    r11 = r11 & numDefine15;
                                    r11 = (r10 + r11) | 0;
                                    r12 = (r11 + numDefine4) | 0;
                                    r11 = r11 >> numDefine2;
                                    heapClassInst.heap32[r11] = r10;
                                    r10 = r12;
                                }
                            } else {
                                r10 = 0;
                            }
                            r11 = (r0 + numDefine20) | 0;
                            if (r8 < 1) {
                                r12 = r11 >> numDefine2;
                                r13 = heapClassInst.heap32[r12];
                            } else {
                                r12 = 0;
                                repeat16: while (true) {
                                    r13 = r11 >> numDefine2;
                                    r13 = heapClassInst.heap32[r13];
                                    r14 = r12 << numDefine2;
                                    r15 = (r13 + r14) | 0;
                                    r15 = r15 >> numDefine2;
                                    r14 = (r10 + r14) | 0;
                                    r15 = heapClassInst.heap32[r15];
                                    r12 = (r12 + 1) | 0;
                                    r14 = r14 >> numDefine2;
                                    heapClassInst.heap32[r14] = r15;
                                    if (!(r8 != r12)) {
                                        break repeat16;
                                    }
                                }
                                r11 = (r0 + numDefine20) | 0;
                            }
                            if (!(r13 == 0)) {
                                r12 = heapClassInst.heapU8[r0 + numDefine24];
                                if (!(r12 == 0)) {
                                    r12 = gNumAlignedFree;
                                    r12 = r12 >> numDefine2;
                                    r14 = heapClassInst.heap32[r12];
                                    r14 = (r14 + 1) | 0;
                                    r13 = r13 >> numDefine2;
                                    heapClassInst.heap32[r12] = r14;
                                    r12 = heapClassInst.heap32[r13 + -1];
                                    heapClassInst.heap32[g0] = r12;
                                    free(i7);
                                }
                                r12 = r11 >> numDefine2;
                                heapClassInst.heap32[r12] = 0;
                            }
                            r12 = 1;
                            r11 = r11 >> numDefine2;
                            heapClassInst.heap8[r0 + numDefine24] = (byte)r12;
                            heapClassInst.heap32[r11] = r10;
                            heapClassInst.heap32[r7 + numDefine4] = r9;
                            if (r8 >= r9) {
                                break repeat3;
                            }
                        }
                        while (true) {
                            r0 = r8 << numDefine2;
                            r10 = heapClassInst.heap32[r7 + numDefine5];
                            r0 = (r10 + r0) | 0;
                            r8 = (r8 + 1) | 0;
                            r0 = r0 >> numDefine2;
                            heapClassInst.heap32[r0] = 0;
                            if (!(r9 != r8)) {
                                break repeat3;
                            }
                        }
                    }
                }
            } while (false);
            heapClassInst.heap32[r7 + numDefine3] = r9;
            repeat29: do {
                if (!(r9 < 1)) {
                    r0 = r1 == 0 ? r3 : r2;
                    r1 = 0;
                    while (true) {
                        r2 = heapClassInst.heap32[r6 + numDefine16];
                        if (r2 == 0) {
                            r2 = (r1 * numDefine20) | 0;
                            r2 = r2 << numDefine2;
                            r3 = heapClassInst.heap32[r6 + numDefine6];
                            r2 = (r3 + r2) | 0;
                            r2 = r2 >> numDefine2;
                            r3 = heapClassInst.heap32[r5 + numDefine48];
                            r2 = heapClassInst.heap32[r2 + numDefine16];
                            heapClassInst.heap32[r5 + numDefine48] = r2;
                            r2 = heapClassInst.heap32[r7 + 1];
                            r8 = r2 >> numDefine2;
                            r8 = heapClassInst.heap32[r8];
                            r8 = r8 >> numDefine2;
                            r8 = heapClassInst.heap32[r8 + numDefine2];
                            r10 = heapClassInst.heap32[r7 + numDefine8];
                            r11 = heapClassInst.heap32[r7 + numDefine5];
                            r12 = r1 << numDefine2;
                            heapClassInst.heap32[g0] = r2;
                            heapClassInst.heap32[g0 + 1] = r4;
                            heapClassInst.heap32[g0 + numDefine2] = r0;
                            heapClassInst.heap32[g0 + numDefine3] = r10;
                            r2 = (r11 + r12) | 0;
                            r2 = r2 >> numDefine2;
                            functionTable.get(r8 >> numDefine2).accept(i7);
                            heapClassInst.heap32[r2] = commonVariable.rg0;
                            heapClassInst.heap32[r5 + numDefine48] = r3;
                        } else {
                            r2 = r1 << numDefine2;
                            r3 = heapClassInst.heap32[r7 + numDefine5];
                            r2 = (r3 + r2) | 0;
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r2] = 0;
                        }
                        r1 = (r1 + 1) | 0;
                        if (!(r9 != r1)) {
                            break repeat29;
                        }
                    }
                }
            } while (false);
            return;
        } else {
            r0 = twoEStr99;
            r1 = twoEStr1100;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine44;
            assertNew(i7);
        }
    }

    public static void znk14btQuantizedBvh26reportAabbOverlappingNodexEP21btNodeOverlapCallbackRK9btVector3S4(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg40;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[fp + numDefine3];
        r4 = heapClassInst.heapU8[r0 + numDefine60];
        repeat1: do {
            if (r4 == 0) {
                r0 = r0 >> numDefine2;
                r4 = heapClassInst.heap32[r0 + numDefine24];
                r5 = 0;
                r6 = r5;
                repeat3: while (true) {
                    r7 = heapClassInst.heap32[r0 + numDefine14];
                    if (r7 > r5) {
                        if (r7 > r6) {
                            r7 = r2 >> numDefine2;
                            r8 = r4 >> numDefine2;
                            r6 = (r6 + 1) | 0;
                            f0 = heapClassInst.heapFloat[r7];
                            f1 = heapClassInst.heapFloat[r8 + numDefine4];
                            if (f0 > f1) {
                                label = numDefine26;
                            } else {
                                r9 = r3 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r9];
                                f1 = heapClassInst.heapFloat[r8];
                                if (f0 < f1) {
                                    label = numDefine26;
                                } else {
                                    r9 = 1;
                                    label = numDefine27;
                                }
                            }
                            if (label == numDefine26) {
                                r9 = 0;
                            }
                            f0 = heapClassInst.heapFloat[r7 + numDefine2];
                            f1 = heapClassInst.heapFloat[r8 + numDefine6];
                            if (f0 > f1) {
                                label = numDefine29;
                            } else {
                                r10 = r3 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r10 + numDefine2];
                                f1 = heapClassInst.heapFloat[r8 + numDefine2];
                                if (f0 < f1) {
                                    label = numDefine29;
                                } else {
                                    label = numDefine30;
                                }
                            }
                            if (label == numDefine29) {
                                r9 = 0;
                            }
                            f0 = heapClassInst.heapFloat[r7 + 1];
                            f1 = heapClassInst.heapFloat[r8 + numDefine5];
                            if (f0 <= f1) {
                                r7 = r3 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r7 + 1];
                                f1 = heapClassInst.heapFloat[r8 + 1];
                                r7 = 0;
                                r10 = heapClassInst.heap32[r8 + numDefine8];
                                r11 = -1;

                                r9 = f0 < f1 ? r7 : r9;
                                r7 = r10 == r11 ? 1 : 0;

                                r12 = r9 & numDefine255;
                                if (!(r12 == 0)) {
                                    r10 = r10 != r11 ? 1 : 0;

                                    r10 = r10 & 1;
                                    if (r10 == 0) {
                                        r10 = r1 >> numDefine2;
                                        r10 = heapClassInst.heap32[r10];
                                        r10 = r10 >> numDefine2;
                                        r10 = heapClassInst.heap32[r10 + numDefine2];
                                        r11 = heapClassInst.heap32[r8 + numDefine10];
                                        r12 = heapClassInst.heap32[r8 + numDefine9];
                                        heapClassInst.heap32[g0] = r1;
                                        heapClassInst.heap32[g0 + 1] = r12;
                                        heapClassInst.heap32[g0 + numDefine2] = r11;
                                        functionTable.get(r10 >> numDefine2).accept(i7);
                                    }
                                }
                            } else {
                                r7 = heapClassInst.heap32[r8 + numDefine8];
                                r9 = -1;

                                r7 = r7 == r9 ? 1 : 0;

                                r9 = 0;
                            }
                            r9 = r9 & numDefine255;
                            if (!(r9 != 0)) {
                                r7 = r7 & 1;
                                if (r7 == 0) {
                                    r7 = heapClassInst.heap32[r8 + numDefine8];
                                    r8 = r7 << numDefine6;
                                    r4 = (r4 + r8) | 0;
                                    r5 = (r7 + r5) | 0;
                                    continue repeat3;
                                }
                            }
                            r4 = (r4 + numDefine64) | 0;
                            r5 = (r5 + 1) | 0;
                        } else {
                            label = numDefine22;
                            break repeat3;
                        }
                    } else {
                        label = numDefine40;
                        break repeat3;
                    }
                }
                switch (label) {
                    case numDefine40:
                        r0 = maxIterations;
                        r0 = r0 >> numDefine2;
                        r1 = heapClassInst.heap32[r0];
                        if (r1 >= r6) {
                            break repeat1;
                        } else {
                            heapClassInst.heap32[r0] = r6;
                            return;
                        }
                    case numDefine22:
                        r0 = twoEStr1921;
                        r1 = twoEStr537;
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r1;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine367;
                        assertNew(i7);
                        break;
                    default:
                        break;
                }
            } else {
                r4 = sp + numDefineNeg6;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r4;
                heapClassInst.heap32[g0 + numDefine2] = r2;
                heapClassInst.heap32[g0 + numDefine3] = 0;
                znk14btQuantizedBvh17quantizeWithClampEPtRK9btVector3i(i7);
                r2 = sp + numDefineNeg12;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r2;
                heapClassInst.heap32[g0 + numDefine2] = r3;
                heapClassInst.heap32[g0 + numDefine3] = 1;
                r3 = r0 >> numDefine2;
                znk14btQuantizedBvh17quantizeWithClampEPtRK9btVector3i(i7);
                r5 = heapClassInst.heap32[r3 + numDefine36];
                if (r5 == numDefine2) {
                    r3 = heapClassInst.heap32[r3 + numDefine34];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r3;
                    heapClassInst.heap32[g0 + numDefine2] = r1;
                    heapClassInst.heap32[g0 + numDefine3] = r4;
                    heapClassInst.heap32[g0 + numDefine4] = r2;
                    znk14btQuantizedBvh42walkRecursiveQuantizedTreeAgainstQueryAabbEPK18btQuantizedBvhNodeP21btNodeOverlapCallbackPtS5(i7);
                    return;
                } else {
                    if (r5 == 1) {
                        r5 = heapClassInst.heapU8[r0 + numDefine60];
                        if (r5 == 0) {
                            r2 = twoEStr212;
                            r3 = twoEStr537;
                            heapClassInst.heap32[g0] = r2;
                            heapClassInst.heap32[g0 + 1] = r3;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine735;
                            assertNew(i7);
                        } else {
                            r5 = heapClassInst.heap32[r3 + numDefine38];
                            if (r5 > 0) {
                                r5 = 0;
                                repeat42: while (true) {
                                    r6 = heapClassInst.heap32[r3 + numDefine40];
                                    r7 = r5 << numDefine5;
                                    r8 = (r6 + r7) | 0;
                                    r9 = heapClassInst.heapU16[(sp + numDefineNeg6) >> 1];
                                    r10 = heapClassInst.heapU16[(r8 + numDefine6) >> 1];
                                    if (!(uint(r9) > uint(r10))) {
                                        r9 = heapClassInst.heapU16[(sp + numDefineNeg12) >> 1];
                                        r6 = heapClassInst.heapU16[(r6 + r7) >> 1];
                                        r7 = r9 & numDefine65535;
                                        r6 = r6 & numDefine65535;
                                        if (!(uint(r7) < uint(r6))) {
                                            r6 = heapClassInst.heapU16[(sp + numDefineNeg2) >> 1];
                                            r7 = heapClassInst.heapU16[(r8 + numDefine10) >> 1];
                                            r6 = r6 & numDefine65535;
                                            r7 = r7 & numDefine65535;
                                            if (!(uint(r6) > uint(r7))) {
                                                r6 = heapClassInst.heapU16[(sp + numDefineNeg8) >> 1];
                                                r7 = heapClassInst.heapU16[(r8 + numDefine4) >> 1];
                                                r6 = r6 & numDefine65535;
                                                r7 = r7 & numDefine65535;
                                                if (!(uint(r6) < uint(r7))) {
                                                    r6 = heapClassInst.heapU16[(sp + numDefineNeg4) >> 1];
                                                    r7 = heapClassInst.heapU16[(r8 + numDefine8) >> 1];
                                                    r6 = r6 & numDefine65535;
                                                    r7 = r7 & numDefine65535;
                                                    if (!(uint(r6) > uint(r7))) {
                                                        r6 = heapClassInst.heapU16[(sp + numDefineNeg10) >> 1];
                                                        r7 = heapClassInst.heapU16[(r8 + numDefine2) >> 1];
                                                        r6 = r6 & numDefine65535;
                                                        r7 = r7 & numDefine65535;
                                                        if (!(uint(r6) < uint(r7))) {
                                                            r6 = r8 >> numDefine2;
                                                            r7 = heapClassInst.heap32[r6 + numDefine3];
                                                            r6 = heapClassInst.heap32[r6 + numDefine4];
                                                            r6 = (r6 + r7) | 0;
                                                            heapClassInst.heap32[g0] = r0;
                                                            heapClassInst.heap32[g0 + 1] = r1;
                                                            heapClassInst.heap32[g0 + numDefine2] = r4;
                                                            heapClassInst.heap32[g0 + numDefine3] = r2;
                                                            heapClassInst.heap32[g0 + numDefine4] = r7;
                                                            heapClassInst.heap32[g0 + numDefine5] = r6;
                                                            znk14btQuantizedBvh26walkStacklessQuantizedTreeEP21btNodeOverlapCallbackPtS2Ii(i7);
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    r5 = (r5 + 1) | 0;
                                    r6 = heapClassInst.heap32[r3 + numDefine38];
                                    if (r6 > r5) {
                                        continue repeat42;
                                    } else {
                                        break repeat1;
                                    }
                                }
                            } else {
                                break repeat1;
                            }
                        }
                    } else {
                        if (r5 != 0) {
                            r0 = twoEStr10;
                            r1 = twoEStr537;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = numDefine341;
                            assertNew(i7);
                        } else {
                            r3 = heapClassInst.heap32[r3 + numDefine14];
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            heapClassInst.heap32[g0 + numDefine2] = r4;
                            heapClassInst.heap32[g0 + numDefine3] = r2;
                            heapClassInst.heap32[g0 + numDefine4] = 0;
                            heapClassInst.heap32[g0 + numDefine5] = r3;
                            znk14btQuantizedBvh26walkStacklessQuantizedTreeEP21btNodeOverlapCallbackPtS2Ii(i7);
                            return;
                        }
                    }
                }
            }
        } while (false);
        return;
    }

    public static void znk14btQuantizedBvh17quantizeWithClampEPtRK9btVector3i(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg32;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine60];
        if (r1 != 0) {
            r1 = heapClassInst.heap32[fp + 1];
            r2 = heapClassInst.heap32[fp + numDefine2];
            r3 = heapClassInst.heap32[fp + numDefine3];
            r2 = r2 >> numDefine2;
            f0 = heapClassInst.heapFloat[r2];
            r4 = sp + numDefineNeg16;
            heapClassInst.heapFloat[fp + numDefineNeg4] = (float)f0;
            f1 = heapClassInst.heapFloat[r2 + 1];
            r5 = r4 >> numDefine2;
            heapClassInst.heapFloat[r5 + 1] = (float)f1;
            f2 = heapClassInst.heapFloat[r2 + numDefine2];
            heapClassInst.heapFloat[r5 + numDefine2] = (float)f2;
            f3 = heapClassInst.heapFloat[r2 + numDefine3];
            r2 = r0 >> numDefine2;
            heapClassInst.heapFloat[r5 + numDefine3] = (float)f3;
            f4 = heapClassInst.heapFloat[r2 + 1];
            if (f0 < f4) {
                heapClassInst.heapFloat[fp + numDefineNeg4] = (float)f4;
                f0 = f4;
            }
            f4 = heapClassInst.heapFloat[r2 + numDefine2];
            if (f1 < f4) {
                heapClassInst.heapFloat[r5 + 1] = (float)f4;
                f1 = f4;
            }
            f4 = heapClassInst.heapFloat[r2 + numDefine3];
            if (f2 < f4) {
                heapClassInst.heapFloat[r5 + numDefine2] = (float)f4;
                f2 = f4;
            }
            f4 = heapClassInst.heapFloat[r2 + numDefine4];
            if (f3 < f4) {
                heapClassInst.heapFloat[r5 + numDefine3] = (float)f4;
                f3 = f4;
            }
            f4 = heapClassInst.heapFloat[r2 + numDefine5];
            if (!(f4 >= f0)) {
                heapClassInst.heapFloat[fp + numDefineNeg4] = (float)f4;
            }
            f0 = heapClassInst.heapFloat[r2 + numDefine6];
            if (!(f0 >= f1)) {
                heapClassInst.heapFloat[r5 + 1] = (float)f0;
            }
            f0 = heapClassInst.heapFloat[r2 + numDefine7];
            if (!(f0 >= f2)) {
                heapClassInst.heapFloat[r5 + numDefine2] = (float)f0;
            }
            f0 = heapClassInst.heapFloat[r2 + numDefine8];
            if (!(f0 >= f3)) {
                heapClassInst.heapFloat[r5 + numDefine3] = (float)f0;
            }
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            heapClassInst.heap32[g0 + numDefine3] = r3;
            znk14btQuantizedBvh8quantizeEPtRK9btVector3i(i7);
            return;
        } else {
            r0 = twoEStr212;
            r1 = twoEStr313;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine420;
            assertNew(i7);
        }
    }

    public static void znk14btQuantizedBvh26walkStacklessQuantizedTreeEP21btNodeOverlapCallbackPtS2Ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine60];
        if (r1 != 0) {
            r1 = heapClassInst.heap32[fp + 1];
            r2 = heapClassInst.heap32[fp + numDefine2];
            r3 = heapClassInst.heap32[fp + numDefine3];
            r4 = heapClassInst.heap32[fp + numDefine4];
            r5 = heapClassInst.heap32[fp + numDefine5];
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine34];
            r6 = r4 << numDefine4;
            r7 = (r5 - r4) | 0;
            r0 = (r0 + r6) | 0;
            r6 = 0;
            repeat3: while (true) {
                if (r4 < r5) {
                    if (r6 < r7) {
                        r8 = heapClassInst.heapU16[r2 >> 1];
                        r9 = heapClassInst.heapU16[(r0 + numDefine6) >> 1];
                        r10 = heapClassInst.heapU16[r3 >> 1];
                        r11 = heapClassInst.heapU16[r0 >> 1];

                        r8 = uint(r8) > uint(r9) ? 1 : 0;
                        r9 = uint(r10) < uint(r11) ? 1 : 0;

                        r10 = heapClassInst.heapU16[(r2 + numDefine4) >> 1];
                        r11 = heapClassInst.heapU16[(r0 + numDefine10) >> 1];
                        r8 = r8 | r9;

                        r9 = uint(r10) > uint(r11) ? 1 : 0;
                        r10 = heapClassInst.heapU16[(r3 + numDefine4) >> 1];
                        r11 = heapClassInst.heapU16[(r0 + numDefine4) >> 1];
                        r8 = r8 | r9;

                        r9 = uint(r10) < uint(r11) ? 1 : 0;
                        r10 = heapClassInst.heapU16[(r2 + numDefine2) >> 1];
                        r11 = heapClassInst.heapU16[(r0 + numDefine8) >> 1];
                        r8 = r8 | r9;

                        r9 = uint(r10) > uint(r11) ? 1 : 0;
                        r10 = heapClassInst.heapU16[(r3 + numDefine2) >> 1];
                        r11 = heapClassInst.heapU16[(r0 + numDefine2) >> 1];
                        r12 = r0 >> numDefine2;
                        r8 = r8 | r9;

                        r9 = uint(r10) < uint(r11) ? 1 : 0;
                        r10 = heapClassInst.heap32[r12 + numDefine3];
                        r6 = (r6 + 1) | 0;
                        r8 = r8 | r9;
                        if (r10 < 0) {
                            label = numDefine10;
                        } else {
                            if (r8 != 0) {
                                label = numDefine10;
                            } else {
                                if (r10 > -1) {
                                    r8 = r1 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8];
                                    r8 = r8 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8 + numDefine2];
                                    r12 = r10 >> numDefine21;
                                    r10 = (int) (r10 & numDefine97151);
                                    heapClassInst.heap32[g0] = r1;
                                    heapClassInst.heap32[g0 + 1] = r12;
                                    heapClassInst.heap32[g0 + numDefine2] = r10;
                                    functionTable.get(r8 >> numDefine2).accept(i7);
                                    label = numDefine11;
                                } else {
                                    label = numDefine8;
                                    break repeat3;
                                }
                            }
                        }
                        if (label == numDefine10) {
                            r9 = 0;

                            r9 = r10 < r9 ? 1 : 0;
                            r8 = r9 & r8;
                            if (r8 != 0) {
                                r8 = heapClassInst.heap32[r12 + numDefine3];
                                if (r8 < 0) {
                                    r9 = r8 << numDefine4;
                                    r0 = (r0 - r9) | 0;
                                    r4 = (r4 - r8) | 0;
                                    continue repeat3;
                                } else {
                                    label = numDefine13;
                                    break repeat3;
                                }
                            }
                        }
                        r0 = (r0 + numDefine16) | 0;
                        r4 = (r4 + 1) | 0;
                    } else {
                        label = numDefine4;
                        break repeat3;
                    }
                } else {
                    label = numDefine16;
                    break repeat3;
                }
            }
            switch (label) {
                case numDefine16:
                    r0 = maxIterations;
                    r0 = r0 >> numDefine2;
                    r1 = heapClassInst.heap32[r0];
                    if (!(r1 >= r6)) {
                        heapClassInst.heap32[r0] = r6;
                    }
                    return;
                case numDefine13:
                    r0 = twoEStr941;
                    r1 = twoEStr313;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine75;
                    assertNew(i7);
                    break;
                case numDefine8:
                    r0 = twoEStr739;
                    r1 = twoEStr313;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine80;
                    assertNew(i7);
                    break;
                case numDefine4:
                    r0 = twoEStr1143;
                    r1 = twoEStr537;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine703;
                    assertNew(i7);
                    break;
                default:
                    break;
            }
        } else {
            r0 = twoEStr212;
            r1 = twoEStr537;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine669;
            assertNew(i7);
        }
    }

    public static void znk14btQuantizedBvh42walkRecursiveQuantizedTreeAgainstQueryAabbEPK18btQuantizedBvhNodeP21btNodeOverlapCallbackPtS5(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[fp + numDefine3];
        r4 = heapClassInst.heap32[fp + numDefine4];
        repeat1: while (true) {
            r5 = heapClassInst.heapU8[r0 + numDefine60];
            if (r5 != 0) {
                r5 = heapClassInst.heapU16[r3 >> 1];
                r6 = heapClassInst.heapU16[(r1 + numDefine6) >> 1];
                if (uint(r5) > uint(r6)) {
                    label = numDefine14;
                    break repeat1;
                } else {
                    r5 = heapClassInst.heapU16[r4 >> 1];
                    r6 = heapClassInst.heapU16[r1 >> 1];
                    r5 = r5 & numDefine65535;
                    r6 = r6 & numDefine65535;
                    if (uint(r5) < uint(r6)) {
                        label = numDefine14;
                        break repeat1;
                    } else {
                        r5 = heapClassInst.heapU16[(r3 + numDefine4) >> 1];
                        r6 = heapClassInst.heapU16[(r1 + numDefine10) >> 1];
                        r5 = r5 & numDefine65535;
                        r6 = r6 & numDefine65535;
                        if (uint(r5) > uint(r6)) {
                            label = numDefine14;
                            break repeat1;
                        } else {
                            r5 = heapClassInst.heapU16[(r4 + numDefine4) >> 1];
                            r6 = heapClassInst.heapU16[(r1 + numDefine4) >> 1];
                            r5 = r5 & numDefine65535;
                            r6 = r6 & numDefine65535;
                            if (uint(r5) < uint(r6)) {
                                label = numDefine14;
                                break repeat1;
                            } else {
                                r5 = heapClassInst.heapU16[(r3 + numDefine2) >> 1];
                                r6 = heapClassInst.heapU16[(r1 + numDefine8) >> 1];
                                r5 = r5 & numDefine65535;
                                r6 = r6 & numDefine65535;
                                if (uint(r5) > uint(r6)) {
                                    label = numDefine14;
                                    break repeat1;
                                } else {
                                    r5 = heapClassInst.heapU16[(r4 + numDefine2) >> 1];
                                    r6 = heapClassInst.heapU16[(r1 + numDefine2) >> 1];
                                    r5 = r5 & numDefine65535;
                                    r6 = r6 & numDefine65535;
                                    if (uint(r5) < uint(r6)) {
                                        label = numDefine14;
                                        break repeat1;
                                    } else {
                                        r5 = r1 >> numDefine2;
                                        r6 = heapClassInst.heap32[r5 + numDefine3];
                                        if (r6 < 0) {
                                            r6 = (r1 + numDefine16) | 0;
                                            heapClassInst.heap32[g0] = r0;
                                            heapClassInst.heap32[g0 + 1] = r6;
                                            heapClassInst.heap32[g0 + numDefine2] = r2;
                                            heapClassInst.heap32[g0 + numDefine3] = r3;
                                            heapClassInst.heap32[g0 + numDefine4] = r4;
                                            znk14btQuantizedBvh42walkRecursiveQuantizedTreeAgainstQueryAabbEPK18btQuantizedBvhNodeP21btNodeOverlapCallbackPtS5(i7);
                                            r5 = heapClassInst.heap32[r5 + numDefine7];
                                            if (r5 < 0) {
                                                r6 = 1;
                                                r5 = (r6 - r5) | 0;
                                                r5 = r5 << numDefine4;
                                                r1 = (r1 + r5) | 0;
                                                continue repeat1;
                                            } else {
                                                r1 = (r1 + numDefine32) | 0;
                                                continue repeat1;
                                            }
                                        } else {
                                            label = numDefine10;
                                            break repeat1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            } else {
                label = numDefine2;
                break repeat1;
            }
        }
        switch (label) {
            case numDefine14:
                return;
            case numDefine2:
                r0 = twoEStr212;
                r1 = twoEStr537;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine419;
                assertNew(i7);
                break;
            case numDefine10:
                r0 = r2 >> numDefine2;
                r0 = heapClassInst.heap32[r0];
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0 + numDefine2];
                r1 = r6 >> numDefine21;
                r3 = (int) (r6 & numDefine97151);
                heapClassInst.heap32[g0] = r2;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = r3;
                functionTable.get(r0 >> numDefine2).accept(i7);
                return;
            default:
                break;
        }
    }

    public static void zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        double f10 = 0.0;
        double f11 = 0.0;
        double f12 = 0.0;
        double f13 = 0.0;
        double f14 = 0.0;
        double f15 = 0.0;
        double f16 = 0.0;
        double f17 = 0.0;
        double f18 = 0.0;
        double f19 = 0.0;
        double f20 = 0.0;
        double f21 = 0.0;
        double f22 = 0.0;
        double f23 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg80;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0 + numDefine4];
        f1 = heapClassInst.heapFloat[r0 + numDefine9];
        f2 = heapClassInst.heapFloat[r0 + numDefine6];
        f3 = heapClassInst.heapFloat[r0 + numDefine8];
        f4 = heapClassInst.heapFloat[r0 + numDefine5];
        f5 = heapClassInst.heapFloat[r0 + numDefine10];
        f6 = f4 * f5;
        f7 = f2 * f1;
        f8 = f2 * f3;
        f9 = f0 * f5;
        f10 = heapClassInst.heapFloat[r0];
        f11 = heapClassInst.heapFloat[r0 + 1];
        f6 = f6 - f7;
        f7 = f8 - f9;
        f8 = f0 * f1;
        f9 = f4 * f3;
        f12 = heapClassInst.heapFloat[r0 + numDefine2];
        f8 = f8 - f9;
        f9 = f10 * f6;
        f13 = f11 * f7;
        f9 = f9 + f13;
        f13 = f12 * f8;
        r0 = heapClassInst.heap32[fp + 1];
        f14 = 1;
        f9 = f9 + f13;
        r0 = r0 >> numDefine2;
        f9 = f14 / f9;
        f13 = f12 * f1;
        f15 = f11 * f5;
        f5 = f10 * f5;
        f16 = f12 * f3;
        f13 = f13 - f15;
        f5 = f5 - f16;
        f15 = f11 * f2;
        f16 = f12 * f4;
        f12 = f12 * f0;
        f2 = f10 * f2;
        f3 = f11 * f3;
        f1 = f10 * f1;
        f6 = f6 * f9;
        f17 = heapClassInst.heapFloat[r0];
        f7 = f7 * f9;
        f18 = heapClassInst.heapFloat[r0 + 1];
        f15 = f15 - f16;
        f2 = f12 - f2;
        f12 = f13 * f9;
        f5 = f5 * f9;
        f1 = f3 - f1;
        f3 = f10 * f4;
        f0 = f11 * f0;
        f4 = f6 * f17;
        f10 = f7 * f18;
        f8 = f8 * f9;
        f11 = heapClassInst.heapFloat[r0 + numDefine2];
        f13 = heapClassInst.heapFloat[r0 + numDefine8];
        f15 = f15 * f9;
        f16 = heapClassInst.heapFloat[r0 + numDefine4];
        f19 = heapClassInst.heapFloat[r0 + numDefine9];
        f2 = f2 * f9;
        f20 = heapClassInst.heapFloat[r0 + numDefine5];
        f0 = f3 - f0;
        f1 = f1 * f9;
        f3 = heapClassInst.heapFloat[r0 + numDefine10];
        f21 = heapClassInst.heapFloat[r0 + numDefine6];
        f22 = f12 * f17;
        f23 = f5 * f18;
        f4 = f4 + f10;
        f10 = f8 * f11;
        f0 = f0 * f9;
        r0 = sp + numDefineNeg48;
        f9 = f15 * f17;
        f17 = f2 * f18;
        f18 = f22 + f23;
        f22 = f1 * f11;
        f4 = f4 + f10;
        r1 = r0 >> numDefine2;
        f9 = f9 + f17;
        f10 = f0 * f11;
        f11 = f18 + f22;
        heapClassInst.heapFloat[fp + numDefineNeg12] = (float)f4;
        f4 = f6 * f16;
        f17 = f7 * f20;
        f9 = f9 + f10;
        heapClassInst.heapFloat[r1 + 1] = (float)f11;
        heapClassInst.heapFloat[r1 + numDefine2] = (float)f9;
        f9 = f12 * f16;
        f10 = f5 * f20;
        f4 = f4 + f17;
        f11 = f8 * f21;
        f16 = f15 * f16;
        f17 = f2 * f20;
        f9 = f9 + f10;
        f10 = f1 * f21;
        f4 = f4 + f11;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        f11 = f16 + f17;
        f16 = f0 * f21;
        f9 = f9 + f10;
        heapClassInst.heapFloat[r1 + numDefine4] = (float)f4;
        f4 = f6 * f13;
        f6 = f7 * f19;
        f7 = f11 + f16;
        heapClassInst.heapFloat[r1 + numDefine5] = (float)f9;
        heapClassInst.heapFloat[r1 + numDefine6] = (float)f7;
        f7 = f12 * f13;
        f5 = f5 * f19;
        f4 = f4 + f6;
        f6 = f8 * f3;
        f8 = f15 * f13;
        f2 = f2 * f19;
        f5 = f7 + f5;
        f1 = f1 * f3;
        f4 = f4 + f6;
        heapClassInst.heap32[r1 + numDefine7] = 0;
        f2 = f8 + f2;
        f0 = f0 * f3;
        f1 = f5 + f1;
        heapClassInst.heapFloat[r1 + numDefine8] = (float)f4;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r1 + numDefine9] = (float)f1;
        heapClassInst.heapFloat[r1 + numDefine10] = (float)f0;
        heapClassInst.heap32[r1 + numDefine11] = 0;
        r1 = sp + numDefineNeg64;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        znk11btMatrix3x311getRotationER12btQuaternion(i7);
        r0 = r1 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + numDefineNeg16];
        f1 = heapClassInst.heapFloat[r0 + 1];
        f2 = heapClassInst.heapFloat[r0 + numDefine2];
        f3 = f0 * f0;
        f4 = f1 * f1;
        f5 = heapClassInst.heapFloat[r0 + numDefine3];
        f3 = f3 + f4;
        f4 = f2 * f2;
        f3 = f3 + f4;
        f4 = f5 * f5;
        f3 = f3 + f4;
        heapClassInst.heapFloat[g0] = (float)f3;
        sqrtf(i7);
        f3 = commonVariable.fg0;
        f4 = 0;
        if (f3 != f4) {
            r1 = heapClassInst.heap32[fp + numDefine2];
            r2 = heapClassInst.heap32[fp + numDefine3];
            f3 = f14 / f3;
            f0 = f0 * f3;
            f1 = f1 * f3;
            heapClassInst.heapFloat[fp + numDefineNeg16] = (float)f0;
            f2 = f2 * f3;
            heapClassInst.heapFloat[r0 + 1] = (float)f1;
            f4 = -1;
            f3 = f5 * f3;
            heapClassInst.heapFloat[r0 + numDefine2] = (float)f2;
            f4 = f3 < f4 ? f4 : f3;
            heapClassInst.heapFloat[r0 + numDefine3] = (float)f3;
            f3 = f4 > f14 ? f14 : f4;
            heapClassInst.heapFloat[g0] = (float)f3;
            acosf(i7);
            r0 = r2 >> numDefine2;
            f3 = commonVariable.fg0 + commonVariable.fg0;
            r1 = r1 >> numDefine2;
            heapClassInst.heapFloat[r0] = (float)f3;
            heapClassInst.heapFloat[r1] = (float)f0;
            f0 = f0 * f0;
            f3 = f1 * f1;
            heapClassInst.heapFloat[r1 + 1] = (float)f1;
            f0 = f0 + f3;
            f1 = f2 * f2;
            f0 = f0 + f1;
            heapClassInst.heapFloat[r1 + numDefine2] = (float)f2;
            heapClassInst.heap32[r1 + numDefine3] = 0;
            f1 = numDefineFloat4044;
            if (f0 >= f1) {
                heapClassInst.heapFloat[g0] = (float)f0;
                sqrtf(i7);
                f0 = f14 / commonVariable.fg0;
                f1 = heapClassInst.heapFloat[r1];
                f1 = f1 * f0;
                heapClassInst.heapFloat[r1] = (float)f1;
                f1 = heapClassInst.heapFloat[r1 + 1];
                f1 = f1 * f0;
                heapClassInst.heapFloat[r1 + 1] = (float)f1;
                f1 = heapClassInst.heapFloat[r1 + numDefine2];
                f0 = f1 * f0;
                heapClassInst.heapFloat[r1 + numDefine2] = (float)f0;
                return;
            } else {
                heapClassInst.heap32[r1] = numDefine53216;
                heapClassInst.heap32[r1 + 1] = 0;
                heapClassInst.heap32[r1 + numDefine2] = 0;
                heapClassInst.heap32[r1 + numDefine3] = 0;
                return;
            }
        } else {
            r0 = twoEStr584;
            r1 = twoEStr685;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine188;
            assertNew(i7);
        }
    }

    public static void znk11btMatrix3x311getRotationER12btQuaternion(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1];
        f1 = heapClassInst.heapFloat[r1 + numDefine5];
        f2 = heapClassInst.heapFloat[r1 + numDefine10];
        f3 = f0 + f1;
        f3 = f3 + f2;
        r2 = heapClassInst.heap32[fp + 1];
        f4 = 0;
        if (f3 <= f4) {
            if (f0 >= f1) {
                r1 = numDefine2;
                r3 = 0;
                r1 = f0 < f2 ? r1 : r3;
            } else {
                r1 = numDefine2;
                r3 = 1;
                r1 = f1 < f2 ? r1 : r3;
            }
            r3 = (r1 + 1) | 0;
            r3 = r3 % numDefine3 | 0;
            r4 = (r1 + numDefine2) | 0;
            r4 = r4 % numDefine3 | 0;
            r5 = r1 << numDefine4;
            r6 = r3 << numDefine4;
            r7 = r4 << numDefine4;
            r5 = (r0 + r5) | 0;
            r1 = r1 << numDefine2;
            r6 = (r0 + r6) | 0;
            r3 = r3 << numDefine2;
            r0 = (r0 + r7) | 0;
            r4 = r4 << numDefine2;
            r7 = (r5 + r1) | 0;
            r8 = (r6 + r3) | 0;
            r7 = r7 >> numDefine2;
            r8 = r8 >> numDefine2;
            r9 = (r0 + r4) | 0;
            r9 = r9 >> numDefine2;
            f0 = heapClassInst.heapFloat[r7];
            f1 = heapClassInst.heapFloat[r8];
            f2 = heapClassInst.heapFloat[r9];
            f0 = f0 - f1;
            f0 = f0 - f2;
            f1 = 1;
            f0 = f0 + f1;
            r7 = sp + numDefineNeg16;
            heapClassInst.heapFloat[g0] = (float)f0;
            r8 = (r7 + r1) | 0;
            f0 = numDefineFloat05;
            sqrtf(i7);
            r9 = (r0 + r3) | 0;
            r10 = (r6 + r4) | 0;
            r8 = r8 >> numDefine2;
            f2 = commonVariable.fg0 * f0;
            r9 = r9 >> numDefine2;
            heapClassInst.heapFloat[r8] = (float)f2;
            r8 = r10 >> numDefine2;
            f2 = heapClassInst.heapFloat[r9];
            f3 = heapClassInst.heapFloat[r8];
            f2 = f2 - f3;
            f0 = f0 / commonVariable.fg0;
            r6 = (r6 + r1) | 0;
            r8 = (r5 + r3) | 0;
            r9 = r7 >> numDefine2;
            f1 = f2 * f0;
            r6 = r6 >> numDefine2;
            heapClassInst.heapFloat[r9 + numDefine3] = (float)f1;
            r8 = r8 >> numDefine2;
            f1 = heapClassInst.heapFloat[r6];
            f2 = heapClassInst.heapFloat[r8];
            r3 = (r7 + r3) | 0;
            f1 = f1 + f2;
            r0 = (r0 + r1) | 0;
            r1 = (r5 + r4) | 0;
            r3 = r3 >> numDefine2;
            f1 = f1 * f0;
            r0 = r0 >> numDefine2;
            heapClassInst.heapFloat[r3] = (float)f1;
            r1 = r1 >> numDefine2;
            f1 = heapClassInst.heapFloat[r0];
            f2 = heapClassInst.heapFloat[r1];
            r0 = (r7 + r4) | 0;
            f1 = f1 + f2;
            r0 = r0 >> numDefine2;
            f0 = f1 * f0;
            heapClassInst.heapFloat[r0] = (float)f0;
            f1 = heapClassInst.heapFloat[fp + numDefineNeg4];
            f3 = heapClassInst.heapFloat[r9 + 1];
            f0 = heapClassInst.heapFloat[r9 + numDefine2];
            f2 = heapClassInst.heapFloat[r9 + numDefine3];
        } else {
            f0 = 1;
            f0 = f3 + f0;
            heapClassInst.heapFloat[g0] = (float)f0;
            r0 = sp + numDefineNeg16;
            f0 = numDefineFloat05;
            sqrtf(i7);
            f2 = commonVariable.fg0 * f0;
            r0 = r0 >> numDefine2;
            heapClassInst.heapFloat[r0 + numDefine3] = (float)f2;
            f3 = heapClassInst.heapFloat[r1 + numDefine9];
            f4 = heapClassInst.heapFloat[r1 + numDefine6];
            f3 = f3 - f4;
            f0 = f0 / commonVariable.fg0;
            f1 = f3 * f0;
            heapClassInst.heapFloat[fp + numDefineNeg4] = (float)f1;
            f3 = heapClassInst.heapFloat[r1 + numDefine2];
            f4 = heapClassInst.heapFloat[r1 + numDefine8];
            f3 = f3 - f4;
            f3 = f3 * f0;
            heapClassInst.heapFloat[r0 + 1] = (float)f3;
            f4 = heapClassInst.heapFloat[r1 + numDefine4];
            f5 = heapClassInst.heapFloat[r1 + 1];
            f4 = f4 - f5;
            f0 = f4 * f0;
            heapClassInst.heapFloat[r0 + numDefine2] = (float)f0;
        }
        r0 = r2 >> numDefine2;
        heapClassInst.heapFloat[r0] = (float)f1;
        heapClassInst.heapFloat[r0 + 1] = (float)f3;
        heapClassInst.heapFloat[r0 + numDefine2] = (float)f0;
        heapClassInst.heapFloat[r0 + numDefine3] = (float)f2;
        return;
    }

    public static void znk13btConvexShape31localGetSupportVertexNonVirtualERK9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg48;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0];
        r1 = sp + numDefineNeg32;
        heapClassInst.heapFloat[fp + numDefineNeg8] = (float)f0;
        f1 = heapClassInst.heapFloat[r0 + 1];
        r2 = r1 >> numDefine2;
        heapClassInst.heapFloat[r2 + 1] = (float)f1;
        f2 = heapClassInst.heapFloat[r0 + numDefine2];
        r3 = heapClassInst.heap32[fp];
        r4 = heapClassInst.heap32[fp + 1];
        heapClassInst.heapFloat[r2 + numDefine2] = (float)f2;
        f3 = f0 * f0;
        f4 = f1 * f1;
        f3 = f3 + f4;
        f4 = f2 * f2;
        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
        f3 = f3 + f4;
        f4 = numDefineFloat4044;
        if (f3 < f4) {
            heapClassInst.heap32[fp + numDefineNeg8] = numDefineNeg30432;
            heapClassInst.heap32[r2 + 1] = numDefineNeg30432;
            f2 = -1;
            heapClassInst.heap32[r2 + numDefine2] = numDefineNeg30432;
            heapClassInst.heap32[r2 + numDefine3] = 0;
            f1 = f2;
            f0 = f2;
        }
        f0 = f0 * f0;
        f1 = f1 * f1;
        f0 = f0 + f1;
        f1 = f2 * f2;
        f0 = f0 + f1;
        heapClassInst.heapFloat[g0] = (float)f0;
        sqrtf(i7);
        f1 = 1;
        f0 = f1 / commonVariable.fg0;
        f1 = heapClassInst.heapFloat[fp + numDefineNeg8];
        f1 = f1 * f0;
        heapClassInst.heapFloat[fp + numDefineNeg8] = (float)f1;
        f2 = heapClassInst.heapFloat[r2 + 1];
        f2 = f2 * f0;
        heapClassInst.heapFloat[r2 + 1] = (float)f2;
        f3 = heapClassInst.heapFloat[r2 + numDefine2];
        f0 = f3 * f0;
        r0 = r4 >> numDefine2;
        heapClassInst.heapFloat[r2 + numDefine2] = (float)f0;
        r5 = heapClassInst.heap32[r0 + 1];
        repeat4: do {
            if (r5 > numDefine7) {
                if (r5 == numDefine13) {
                    f3 = heapClassInst.heapFloat[r0 + numDefine11];
                    label = numDefine16;
                    break repeat4;
                } else {
                    if (r5 == numDefine10) {
                        f3 = heapClassInst.heapFloat[r0 + numDefine11];
                        label = numDefine16;
                        break repeat4;
                    } else {
                        if (r5 != numDefine8) {
                            label = numDefine15;
                            break repeat4;
                        } else {
                            f3 = heapClassInst.heapFloat[r0 + numDefine7];
                            f4 = heapClassInst.heapFloat[r0 + numDefine3];
                            f3 = f3 * f4;
                            label = numDefine16;
                            break repeat4;
                        }
                    }
                }
            } else {
                if (r5 == 0) {
                    f3 = heapClassInst.heapFloat[r0 + numDefine11];
                    label = numDefine16;
                    break repeat4;
                } else {
                    if (r5 == 1) {
                        f3 = heapClassInst.heapFloat[r0 + numDefine11];
                        label = numDefine16;
                    } else {
                        r5 = (r5 + numDefineNeg4) | 0;
                        if (uint(r5) < uint(numDefine2)) {
                            f3 = heapClassInst.heapFloat[r0 + numDefine11];
                            label = numDefine16;
                        } else {
                            label = numDefine15;
                        }
                    }
                }
            }
        } while (false);
        if (label == numDefine15) {
            r0 = heapClassInst.heap32[r0];
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefine11];
            heapClassInst.heap32[g0] = r4;
            functionTable.get(r0 >> numDefine2).accept(i7);
            f3 = commonVariable.fg0;
            f0 = heapClassInst.heapFloat[r2 + numDefine2];
            f2 = heapClassInst.heapFloat[r2 + 1];
            f1 = heapClassInst.heapFloat[fp + numDefineNeg8];
        }
        r0 = sp + numDefineNeg16;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3(i7);
        r0 = r0 >> numDefine2;
        f1 = f1 * f3;
        f4 = heapClassInst.heapFloat[fp + numDefineNeg4];
        f5 = heapClassInst.heapFloat[r0 + numDefine2];
        f6 = heapClassInst.heapFloat[r0 + 1];
        f2 = f2 * f3;
        r0 = r3 >> numDefine2;
        f1 = f4 + f1;
        f0 = f0 * f3;
        f2 = f6 + f2;
        heapClassInst.heapFloat[r0] = (float)f1;
        f0 = f5 + f0;
        heapClassInst.heapFloat[r0 + 1] = (float)f2;
        heapClassInst.heapFloat[r0 + numDefine2] = (float)f0;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        
    }

    public static void znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        double f10 = 0.0;
        double f11 = 0.0;
        double f12 = 0.0;
        double f13 = 0.0;
        double f14 = 0.0;
        double f15 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg120;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + 1];
        r3 = heapClassInst.heap32[fp];
        r4 = heapClassInst.heap32[fp + numDefine2];
        repeat1: do {
            if (r2 > numDefine4) {
                if (r2 > numDefine9) {
                    if (r2 == numDefine10) {
                        r2 = heapClassInst.heap32[r1 + numDefine13];
                        r5 = (r2 + numDefine2) | 0;
                        r4 = r4 >> numDefine2;
                        r5 = r5 % numDefine3 | 0;
                        f0 = heapClassInst.heapFloat[r4];
                        f1 = heapClassInst.heapFloat[r4 + 1];
                        r2 = r2 << numDefine2;
                        r0 = (r0 + numDefine28) | 0;
                        r5 = r5 << numDefine2;
                        f2 = heapClassInst.heapFloat[r4 + numDefine2];
                        r4 = (r0 + r2) | 0;
                        r0 = (r0 + r5) | 0;
                        f3 = f0 * f0;
                        f4 = f1 * f1;
                        r4 = r4 >> numDefine2;
                        r0 = r0 >> numDefine2;
                        f3 = f3 + f4;
                        f4 = f2 * f2;
                        f3 = f3 + f4;
                        f4 = heapClassInst.heapFloat[r4];
                        f5 = heapClassInst.heapFloat[r0];
                        f6 = numDefineFloat9165;
                        if (f3 >= f6) {
                            heapClassInst.heapFloat[g0] = (float)f3;
                            f3 = 1;
                            sqrtf(i7);
                            f3 = f3 / commonVariable.fg0;
                            f0 = f0 * f3;
                            f1 = f1 * f3;
                            f2 = f2 * f3;
                        } else {
                            f0 = 1;
                            f1 = 0;
                            f2 = f1;
                        }
                        r0 = sp + numDefineNeg64;
                        r4 = r0 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg16] = 0;
                        heapClassInst.heap32[r4 + 1] = 0;
                        r0 = (r0 + r2) | 0;
                        heapClassInst.heap32[r4 + numDefine2] = 0;
                        r0 = r0 >> numDefine2;
                        heapClassInst.heap32[r4 + numDefine3] = 0;
                        heapClassInst.heapFloat[r0] = (float)f4;
                        f3 = heapClassInst.heapFloat[r1 + numDefine4];
                        f6 = heapClassInst.heapFloat[r1 + numDefine3];
                        f7 = heapClassInst.heapFloat[r1 + numDefine5];
                        f3 = f1 * f3;
                        f6 = f0 * f6;
                        f8 = heapClassInst.heapFloat[r1 + numDefine11];
                        f7 = f2 * f7;
                        f3 = f3 * f5;
                        f9 = heapClassInst.heapFloat[r4 + 1];
                        f6 = f6 * f5;
                        f10 = heapClassInst.heapFloat[fp + numDefineNeg16];
                        f5 = f7 * f5;
                        f7 = heapClassInst.heapFloat[r4 + numDefine2];
                        f11 = f1 * f8;
                        f9 = f9 + f3;
                        f12 = f0 * f8;
                        f10 = f10 + f6;
                        f9 = f9 - f11;
                        f10 = f10 - f12;
                        f8 = f2 * f8;
                        f7 = f7 + f5;
                        f7 = f7 - f8;
                        f13 = f0 * f10;
                        f14 = f1 * f9;
                        f13 = f13 + f14;
                        f14 = f2 * f7;
                        f13 = f13 + f14;
                        f14 = numDefineNeg49440;
                        if (f13 > f14) {
                            f14 = f13;
                        } else {
                            f10 = 0;
                            f9 = f10;
                            f7 = f10;
                        }
                        r0 = sp + numDefineNeg80;
                        r1 = r0 >> numDefine2;
                        heapClassInst.heap32[fp + numDefineNeg20] = 0;
                        heapClassInst.heap32[r1 + 1] = 0;
                        r0 = (r0 + r2) | 0;
                        heapClassInst.heap32[r1 + numDefine2] = 0;
                        r0 = r0 >> numDefine2;
                        f4 = -f4;
                        heapClassInst.heap32[r1 + numDefine3] = 0;
                        heapClassInst.heapFloat[r0] = (float)f4;
                        f4 = heapClassInst.heapFloat[r1 + 1];
                        f13 = heapClassInst.heapFloat[fp + numDefineNeg20];
                        f15 = heapClassInst.heapFloat[r1 + numDefine2];
                        f3 = f4 + f3;
                        f4 = f13 + f6;
                        f4 = f4 - f12;
                        f3 = f3 - f11;
                        f5 = f15 + f5;
                        f0 = f0 * f4;
                        f1 = f1 * f3;
                        f5 = f5 - f8;
                        f0 = f0 + f1;
                        f1 = f2 * f5;
                        f0 = f0 + f1;
                        r0 = r3 >> numDefine2;
                        f1 = f0 > f14 ? f4 : f10;
                        f2 = f0 > f14 ? f3 : f9;
                        heapClassInst.heapFloat[r0] = (float)f1;
                        f0 = f0 > f14 ? f5 : f7;
                        label = numDefine11;
                        break repeat1;
                    } else {
                        if (r2 == numDefine13) {
                            r0 = sp + numDefineNeg16;
                            r2 = r0 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg4] = heapClassInst.heap32[r1 + numDefine7];
                            heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r1 + numDefine8];
                            heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
                            r4 = r4 >> numDefine2;
                            heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r1 + numDefine10];
                            r2 = sp + numDefineNeg32;
                            heapClassInst.heap32[fp + numDefineNeg8] = heapClassInst.heap32[r4];
                            f0 = heapClassInst.heapFloat[r4 + 1];
                            r5 = r2 >> numDefine2;
                            heapClassInst.heapFloat[r5 + 1] = (float)f0;
                            f1 = heapClassInst.heapFloat[r4 + numDefine2];
                            heapClassInst.heapFloat[r5 + numDefine2] = (float)f1;
                            heapClassInst.heap32[r5 + numDefine3] = 0;
                            r1 = heapClassInst.heap32[r1 + numDefine13];
                            if (r1 == numDefine2) {
                                r4 = 0;
                                r5 = numDefine2;
                                r6 = 1;
                                f1 = f0;
                            } else {
                                if (r1 == 1) {
                                    r4 = 0;
                                    r5 = 1;
                                    r6 = numDefine2;
                                } else {
                                    if (r1 != 0) {
                                        r0 = twoEStr10;
                                        r1 = twoEStr7250;
                                        heapClassInst.heap32[g0] = r0;
                                        heapClassInst.heap32[g0 + 1] = r1;
                                        heapClassInst.heap32[g0 + numDefine2] = numDefine175;
                                        assertNew(i7);
                                    } else {
                                        r4 = 1;
                                        r5 = 0;
                                        r6 = numDefine2;
                                    }
                                }
                            }
                            r1 = r1 << numDefine2;
                            r4 = r4 << numDefine2;
                            r7 = (r0 + r4) | 0;
                            r0 = (r0 + r1) | 0;
                            r1 = (r2 + r4) | 0;
                            r7 = r7 >> numDefine2;
                            r0 = r0 >> numDefine2;
                            r1 = r1 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r1];
                            f2 = heapClassInst.heapFloat[r7];
                            f3 = heapClassInst.heapFloat[r0];
                            f4 = f0 * f0;
                            f5 = f1 * f1;
                            f4 = f4 + f5;
                            heapClassInst.heapFloat[g0] = (float)f4;
                            sqrtf(i7);
                            f4 = commonVariable.fg0;
                            f5 = 0;
                            if (f4 == f5) {
                                r0 = sp + numDefineNeg48;
                                r1 = (r0 + r4) | 0;
                                r4 = r5 << numDefine2;
                                r2 = (r2 + r4) | 0;
                                r1 = r1 >> numDefine2;
                                r2 = r2 >> numDefine2;
                                heapClassInst.heapFloat[r1] = (float)f2;
                                f0 = heapClassInst.heapFloat[r2];
                                if (f0 < f5) {
                                    f3 = -f3;
                                }
                                r1 = r6 << numDefine2;
                                r4 = (r0 + r4) | 0;
                                r1 = (r0 + r1) | 0;
                                r4 = r4 >> numDefine2;
                                r1 = r1 >> numDefine2;
                                heapClassInst.heapFloat[r4] = (float)f3;
                                r3 = r3 >> numDefine2;
                                heapClassInst.heap32[r1] = 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r3] = heapClassInst.heap32[fp + numDefineNeg12];
                                heapClassInst.heap32[r3 + 1] = heapClassInst.heap32[r0 + 1];
                                heapClassInst.heap32[r3 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
                                heapClassInst.heap32[r3 + numDefine3] = 0;
                                return;
                            } else {
                                r0 = sp + numDefineNeg48;
                                r4 = (r0 + r4) | 0;
                                f2 = f2 / f4;
                                r1 = r5 << numDefine2;
                                r2 = (r2 + r1) | 0;
                                r4 = r4 >> numDefine2;
                                f0 = f0 * f2;
                                r2 = r2 >> numDefine2;
                                heapClassInst.heapFloat[r4] = (float)f0;
                                f0 = heapClassInst.heapFloat[r2];
                                if (f0 < f5) {
                                    f3 = -f3;
                                }
                                r4 = r6 << numDefine2;
                                r1 = (r0 + r1) | 0;
                                r4 = (r0 + r4) | 0;
                                r1 = r1 >> numDefine2;
                                r4 = r4 >> numDefine2;
                                f2 = f1 * f2;
                                heapClassInst.heapFloat[r1] = (float)f3;
                                r1 = r3 >> numDefine2;
                                heapClassInst.heapFloat[r4] = (float)f2;
                                r4 = r0 >> numDefine2;
                                heapClassInst.heap32[r1] = heapClassInst.heap32[fp + numDefineNeg12];
                                heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r4 + 1];
                                heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                                heapClassInst.heap32[r1 + numDefine3] = 0;
                                return;
                            }
                        } else {
                            label = numDefine40;
                            break repeat1;
                        }
                    }
                } else {
                    if (r2 == numDefine5) {
                        r0 = r4 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r1 + numDefine5];
                        r4 = heapClassInst.heap32[r1 + numDefine22];
                        label = numDefine38;
                        break repeat1;
                    } else {
                        if (r2 == numDefine8) {
                            r0 = r3 >> numDefine2;
                            heapClassInst.heap32[r0] = 0;
                            heapClassInst.heap32[r0 + 1] = 0;
                            heapClassInst.heap32[r0 + numDefine2] = 0;
                            heapClassInst.heap32[r0 + numDefine3] = 0;
                            return;
                        } else {
                            label = numDefine40;
                            break repeat1;
                        }
                    }
                }
            } else {
                if (r2 == 0) {
                    r0 = r4 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r1 + numDefine7];
                    f1 = heapClassInst.heapFloat[r1 + numDefine9];
                    f2 = heapClassInst.heapFloat[r1 + numDefine8];
                    f3 = 0;
                    f4 = -f0;
                    f5 = heapClassInst.heapFloat[r0];
                    f6 = heapClassInst.heapFloat[r0 + numDefine2];
                    f7 = heapClassInst.heapFloat[r0 + 1];
                    f8 = -f2;
                    r0 = r3 >> numDefine2;
                    f0 = f5 < f3 ? f4 : f0;
                    f4 = -f1;
                    f2 = f7 < f3 ? f8 : f2;
                    heapClassInst.heapFloat[r0] = (float)f0;
                    f0 = f6 < f3 ? f4 : f1;
                    label = numDefine11;
                    break repeat1;
                } else {
                    if (r2 == 1) {
                        r4 = r4 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r1 + numDefine13];
                        f1 = heapClassInst.heapFloat[r4];
                        f2 = heapClassInst.heapFloat[r1 + numDefine17];
                        f3 = heapClassInst.heapFloat[r1 + numDefine21];
                        f4 = heapClassInst.heapFloat[r1 + numDefine14];
                        f5 = heapClassInst.heapFloat[r4 + 1];
                        f6 = heapClassInst.heapFloat[r1 + numDefine18];
                        f7 = heapClassInst.heapFloat[r1 + numDefine22];
                        f0 = f1 * f0;
                        f4 = f5 * f4;
                        f8 = heapClassInst.heapFloat[r1 + numDefine15];
                        f9 = heapClassInst.heapFloat[r4 + numDefine2];
                        f10 = heapClassInst.heapFloat[r1 + numDefine19];
                        f11 = heapClassInst.heapFloat[r1 + numDefine23];
                        f2 = f1 * f2;
                        f6 = f5 * f6;
                        f1 = f1 * f3;
                        f3 = f5 * f7;
                        f0 = f0 + f4;
                        f4 = f9 * f8;
                        f2 = f2 + f6;
                        f5 = f9 * f10;
                        f1 = f1 + f3;
                        f3 = f9 * f11;
                        f0 = f0 + f4;
                        f2 = f2 + f5;
                        f1 = f1 + f3;
                        if (f0 >= f2) {
                            r1 = numDefine2;
                            r4 = 0;
                            r1 = f0 < f1 ? r1 : r4;
                        } else {
                            r1 = numDefine2;
                            r4 = 1;
                            r1 = f2 < f1 ? r1 : r4;
                        }
                        r1 = r1 << numDefine4;
                        r0 = (r0 + r1) | 0;
                        r0 = r0 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r0 + numDefine15];
                        f1 = heapClassInst.heapFloat[r0 + numDefine14];
                        r1 = r3 >> numDefine2;
                        heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine13];
                        heapClassInst.heapFloat[r1 + 1] = (float)f1;
                        heapClassInst.heapFloat[r1 + numDefine2] = (float)f0;
                        heapClassInst.heap32[r1 + numDefine3] = 0;
                        return;
                    } else {
                        if (r2 == numDefine4) {
                            r0 = r4 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r1 + numDefine5];
                            r4 = heapClassInst.heap32[r1 + numDefine25];
                            label = numDefine38;
                        } else {
                            label = numDefine40;
                        }
                    }
                }
            }
        } while (false);
        switch (label) {
            case numDefine11:
                heapClassInst.heapFloat[r0 + 1] = (float)f2;
                heapClassInst.heapFloat[r0 + numDefine2] = (float)f0;
                heapClassInst.heap32[r0 + numDefine3] = 0;
                return;
            case numDefine40:
                r1 = heapClassInst.heap32[r1];
                r1 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r1 + numDefine16];
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r0;
                heapClassInst.heap32[g0 + numDefine2] = r4;
                functionTable.get(r1 >> numDefine2).accept(i7);
                return;
            case numDefine38:
                r2 = heapClassInst.heap32[r1 + numDefine23];
                f1 = heapClassInst.heapFloat[r0];
                f2 = heapClassInst.heapFloat[r0 + 1];
                f3 = heapClassInst.heapFloat[r0 + numDefine2];
                f4 = heapClassInst.heapFloat[r1 + numDefine3];
                f5 = heapClassInst.heapFloat[r1 + numDefine4];
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heapFloat[g0 + 1] = (float)f1;
                heapClassInst.heapFloat[g0 + numDefine2] = (float)f2;
                heapClassInst.heapFloat[g0 + numDefine3] = (float)f3;
                heapClassInst.heap32[g0 + numDefine4] = r4;
                heapClassInst.heap32[g0 + numDefine5] = r2;
                heapClassInst.heapFloat[g0 + numDefine6] = (float)f4;
                heapClassInst.heapFloat[g0 + numDefine7] = (float)f5;
                heapClassInst.heapFloat[g0 + numDefine8] = (float)f0;
                zl17convexHullSupportRK9btVector3PS0IS1(i7);
                return;
            default:
                break;
        }
        return;
    }

    public static void zl17convexHullSupportRK9btVector3PS0IS1(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        double f2 = 0.0;
        double f3 = 0.0;
        double f4 = 0.0;
        double f5 = 0.0;
        double f6 = 0.0;
        double f7 = 0.0;
        double f8 = 0.0;
        double f9 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine5];
        if (!(r0 < 1)) {
            f0 = heapClassInst.heapFloat[fp + numDefine8];
            f1 = heapClassInst.heapFloat[fp + numDefine3];
            f2 = heapClassInst.heapFloat[fp + numDefine7];
            f3 = heapClassInst.heapFloat[fp + numDefine2];
            f4 = heapClassInst.heapFloat[fp + numDefine6];
            f5 = heapClassInst.heapFloat[fp + 1];
            r1 = heapClassInst.heap32[fp];
            r2 = heapClassInst.heap32[fp + numDefine4];
            f1 = f1 * f0;
            f3 = f3 * f2;
            f5 = f5 * f4;
            r3 = 0;
            r4 = -1;
            f6 = numDefineNeg49440;
            repeat3: while (true) {
                r5 = r3 << numDefine4;
                r5 = (r2 + r5) | 0;
                r5 = r5 >> numDefine2;
                f7 = heapClassInst.heapFloat[r5];
                f8 = heapClassInst.heapFloat[r5 + 1];
                f7 = f5 * f7;
                f8 = f3 * f8;
                f9 = heapClassInst.heapFloat[r5 + numDefine2];
                f7 = f7 + f8;
                f8 = f1 * f9;
                f7 = f7 + f8;
                r5 = (r3 + 1) | 0;
                r4 = f7 > f6 ? r3 : r4;
                f6 = f7 > f6 ? f7 : f6;
                r3 = r5;
                if (!(r0 != r5)) {
                    break repeat3;
                }
            }
            if (r4 > -1) {
                r0 = r4 << numDefine4;
                r0 = (r2 + r0) | 0;
                r0 = r0 >> numDefine2;
                f1 = heapClassInst.heapFloat[r0];
                f3 = heapClassInst.heapFloat[r0 + numDefine2];
                f5 = heapClassInst.heapFloat[r0 + 1];
                r0 = r1 >> numDefine2;
                f1 = f1 * f4;
                f2 = f5 * f2;
                heapClassInst.heapFloat[r0] = (float)f1;
                f0 = f3 * f0;
                heapClassInst.heapFloat[r0 + 1] = (float)f2;
                heapClassInst.heapFloat[r0 + numDefine2] = (float)f0;
                heapClassInst.heap32[r0 + numDefine3] = 0;
                return;
            }
        }
        r1 = twoEStr6249;
        r2 = twoEStr7250;
        heapClassInst.heap32[g0] = r1;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = numDefine108;
        assertNew(i7);
    }

    public static void zn15CProfileManager13StartProfileEPKc(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = zn15CProfileManager11CurrentNodeE;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0];
        r2 = heapClassInst.heap32[fp];
        r3 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[r3];
        if (r4 != r2) {
            r4 = (r1 + numDefine24) | 0;
            repeat3: while (true) {
                r4 = r4 >> numDefine2;
                r4 = heapClassInst.heap32[r4];
                if (r4 != 0) {
                    r5 = r4 >> numDefine2;
                    r5 = heapClassInst.heap32[r5];
                    if (r5 != r2) {
                        r4 = (r4 + numDefine28) | 0;
                    } else {
                        label = numDefine3;
                        break repeat3;
                    }
                } else {
                    label = numDefine6;
                    break repeat3;
                }
            }
            switch (label) {
                case numDefine6:
                    heapClassInst.heap32[g0] = numDefine32;
                    znwj(i7);
                    r4 = commonVariable.rg0;
                    r5 = r4 >> numDefine2;
                    heapClassInst.heap32[r5] = r2;
                    heapClassInst.heap32[r5 + 1] = 0;
                    heapClassInst.heap32[r5 + numDefine2] = 0;
                    heapClassInst.heap32[r5 + numDefine3] = 0;
                    heapClassInst.heap32[r5 + numDefine4] = 0;
                    heapClassInst.heap32[r5 + numDefine5] = r1;
                    heapClassInst.heap32[r5 + numDefine6] = 0;
                    heapClassInst.heap32[r5 + numDefine7] = 0;
                    heapClassInst.heap32[g0] = r4;
                    zn12CProfileNode5ResetEv(i7);
                    r1 = heapClassInst.heap32[r3 + numDefine6];
                    heapClassInst.heap32[r5 + numDefine7] = r1;
                    heapClassInst.heap32[r3 + numDefine6] = r4;
                    r1 = r4;
                    break;
                case numDefine3:
                    r1 = r4;
                    break;
                default:
                    break;
            }
            heapClassInst.heap32[r0] = r1;
        }
        r0 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + 1];
        r1 = (r1 + 1) | 0;
        heapClassInst.heap32[r0 + 1] = r1;
        r1 = heapClassInst.heap32[r0 + numDefine4];
        r2 = (r1 + 1) | 0;
        heapClassInst.heap32[r0 + numDefine4] = r2;
        if (!(r1 != 0)) {
            r1 = sp + numDefineNeg8;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = 0;
            r2 = zl13gProfileClock2E0;
            getTimeOfDay(i7);
            r2 = r2 >> numDefine2;
            r2 = heapClassInst.heap32[r2];
            r2 = r2 >> numDefine2;
            r1 = r1 >> numDefine2;
            r3 = heapClassInst.heap32[fp + numDefineNeg2];
            r4 = heapClassInst.heap32[r2];
            r3 = (r3 - r4) | 0;
            r1 = heapClassInst.heap32[r1 + 1];
            r2 = heapClassInst.heap32[r2 + 1];
            r1 = (r1 - r2) | 0;
            r2 = (int) ((r3 * numDefineN6) | 0);
            r1 = (r1 + r2) | 0;
            heapClassInst.heap32[r0 + numDefine3] = r1;
        }
        return;
    }

    public static void zn12CProfileNode5ResetEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        repeat1: while (true) {
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r0 + 1] = 0;
            heapClassInst.heap32[r0 + numDefine2] = 0;
            r1 = heapClassInst.heap32[r0 + numDefine6];
            if (!(r1 == 0)) {
                heapClassInst.heap32[g0] = r1;
                zn12CProfileNode5ResetEv(i7);
            }
            r0 = heapClassInst.heap32[r0 + numDefine7];
            if (r0 != 0) {
                continue repeat1;
            } else {
                break repeat1;
            }
        }
        return;
    }

    public static void powf(int sp){
        float value = heapClassInst.heapFloat[sp >> numDefine2];
        float value2 = heapClassInst.heapFloat[(sp + numDefine4) >> numDefine2];
        commonVariable.fg0 = Math.pow(value, value2);
    }

    public static void abort(int sp){
        assert1(false);
    }

    public static void znaj(int sp){
        mallocNew(sp);
    }

    public static void zdaPv(int sp){
        free(sp);
    }

    public static void emitOpenHarmony32(long data){
        BigInteger temp = new BigInteger(String.valueOf(data));
        heapClassInst.heapU32[commonVariable.gAddrEmit >> numDefine2] = temp.intValue();
        commonVariable.gAddrEmit += numDefine4;
    }

    public static void emitOpenHarmonyStart(int addr){
        commonVariable.gAddrEmit = addr;
    }

    public static void emitOpenHarmony8(int data){
        heapClassInst.heapU8[commonVariable.gAddrEmit] = (byte) data;
        commonVariable.gAddrEmit += 1;
    }

    public static void emitOpenHarmony16(int data){
        heapClassInst.heapU16[commonVariable.gAddrEmit >> 1] = (short) data;
        commonVariable.gAddrEmit += numDefine2;
    }

    public static void emitOpenHarmonyFill(int data,int size) {
        for (int j = 0; j < size; j++) {
            heapClassInst.heapU8[commonVariable.gAddrEmit] = (byte) data;
            commonVariable.gAddrEmit += 1;
        }
    }

    public static void emitOpenHarmonyString(String v) {
        for (int i = 0; i < v.length(); i++) {
            char ch = v.charAt(i);
            int data = (int) ch;
            heapClassInst.heapU8[commonVariable.gAddrEmit] = (byte) data;
            commonVariable.gAddrEmit += 1;
        }
    }

    public static void initHeap(){
//        short signedByte = -1;
//        short unsignedInt = (short) (signedByte & 0xff);
//        heapClassInst.heap = new byte[mandreelTotalMemory];
//        byte[] heap1 = heapClassInst.heap;
//        ByteBuffer heapBuffer = ByteBuffer.wrap(heap1);
//        heapClassInst.heap8 = heap1;
//        heapClassInst.heapU8 = heapBuffer.asUnsignedBuffer();
//        ShortBuffer heap2 = heapBuffer.asShortBuffer();
//        heapClassInst.heap16 = heap2;
//        heapClassInst.heapU16 = heap2.asUnsignedBuffer();
//        IntBuffer heap3 = heapBuffer.asIntBuffer();
//        heapClassInst.heap32 = heap3;
//        heapClassInst.heapU32 = heap3.asUnsignedBuffer();
//        FloatBuffer heap4 = heapBuffer.asFloatBuffer();
//        heapClassInst.heapFloat = heap4;
//        DoubleBuffer heap5 = heapBuffer.asDoubleBuffer();
//        heapClassInst.heapDouble = heap5;
//        for (int i = 0; i < mandreelTotalMemory / numDefine4; i++) {
//            heapClassInst.heapU32[i] = 0;
//        }

        heapClassInst.heap = ByteBuffer.allocate(mandreelTotalMemory);
        heapClassInst.heap8 = new byte[mandreelTotalMemory];
        heapClassInst.heap16 = new short[mandreelTotalMemory / 2];
        heapClassInst.heap32 = new int[mandreelTotalMemory / 4];
        heapClassInst.heapFloat = new float[mandreelTotalMemory / 4];
        heapClassInst.heapDouble = new double[mandreelTotalMemory / 8];
        for (int i = 0; i < mandreelTotalMemory / numDefine4; i++) {
            heapClassInst.heap32[i] = 0;
        }
    }

    public static void assert1Unalign(){
        dump("fatal error: unaligned memory access detected!!!!");
        assert1(false);
    }

    public static void cxaPureVirtual(int sp){
        assert1(false);
        
    }

    public static void mandreelCallConstructors(int Ptr,int size,int stackPos){
        int ptr = Ptr;
        ptr = ptr >> numDefine2;
        for (int i = 0; i < size; ++i) {
            int tag = heapClassInst.heap32[ptr];
            int ptrId = heapClassInst.heap32[ptr + 1];
            functionTable.get(ptrId >> numDefine2).accept(stackPos);
            ptr += numDefine2;
        }
    }

    public static void cmpfacets(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        r1 = heapClassInst.heap32[r1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine5];
        r3 = heapClassInst.heap32[r1 + numDefine5];
        if (r2 != r3) {
            r0 = (r3 - r2) | 0;
            commonVariable.rg0 = r0;
            
        } else {
            r2 = heapClassInst.heap32[r1 + 1];
            r3 = heapClassInst.heap32[r0 + 1];
            r0 = twoEStr538;
            r3 = r3 == 0 ? r0 : r3;
            r2 = r2 == 0 ? r0 : r2;
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r2;
            strcmp(i7);
            
        }
    }

    public static void strcmp(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = r1 ^ r0;
        r2 = r2 & numDefine3;
        repeat1: do {
            if (r2 == 0) {
                r2 = r0 & numDefine3;
                repeat3: do {
                    if (r2 != 0) {
                        r2 = r0 | numDefineNeg4;
                        repeat5: while (true) {
                            if (r2 != 0) {
                                r3 = heapClassInst.heapU8[r0];
                                r4 = heapClassInst.heapU8[r1];
                                if (r3 == 0) {
                                    break repeat5;
                                } else {
                                    r5 = r4 & numDefine255;
                                    if (r3 == r5) {
                                        r0 = (r0 + 1) | 0;
                                        r1 = (r1 + 1) | 0;
                                        r2 = (r2 + 1) | 0;
                                    } else {
                                        break repeat5;
                                    }
                                }
                            } else {
                                break repeat3;
                            }
                        }
                        r0 = r3 << numDefine24;
                        r1 = r4 << numDefine24;
                        break repeat1;
                    }
                } while (false);
                repeat11: while (true) {
                    r2 = r0 >> numDefine2;
                    r2 = heapClassInst.heap32[r2];
                    r3 = r1 >> numDefine2;
                    r4 = (int) (r2 & numDefineNeg62144);
                    r3 = heapClassInst.heap32[r3];
                    r4 = (int) (r4 ^ numDefineNeg62144);
                    r5 = (int) ((r2 + numDefineNeg43009) | 0);
                    r4 = r4 & r5;
                    if (r4 != 0) {
                        break repeat11;
                    } else {
                        r4 = (int) (r3 & numDefineNeg62144);
                        r4 = (int) (r4 ^ numDefineNeg62144);
                        r5 = (int) ((r3 + numDefineNeg43009) | 0);
                        r4 = r4 & r5;
                        if (r4 != 0) {
                            break repeat11;
                        } else {
                            r0 = (r0 + numDefine4) | 0;
                            r1 = (r1 + numDefine4) | 0;
                            if (!(r2 == r3)) {
                                break repeat11;
                            }
                        }
                    }
                }
                r0 = r2 & numDefine255;
                repeat16: do {
                    if (!(r0 == 0)) {
                        r0 = r2 & numDefine255;
                        r1 = r3 & numDefine255;
                        if (!(r0 != r1)) {
                            label = numDefine19;
                            while (true) {
                                r2 = r2 >>> numDefine8;
                                r3 = r3 >>> numDefine8;
                                r0 = r2 & numDefine255;
                                if (r0 == 0) {
                                    break repeat16;
                                } else {
                                    r1 = r3 & numDefine255;
                                    if (!(r0 == r1)) {
                                        break repeat16;
                                    }
                                }
                            }
                        }
                    }
                } while (false);
                r2 = r2 & numDefine255;
                r3 = r3 & numDefine255;
                r2 = (r2 - r3) | 0;
                commonVariable.rg0 = r2;
                return;
            } else {
                repeat22: while (true) {
                    r2 = heapClassInst.heapU8[r0];
                    r3 = heapClassInst.heapU8[r1];
                    if (r2 == 0) {
                        break repeat22;
                    } else {
                        r4 = r3 & numDefine255;
                        if (r2 == r4) {
                            r0 = (r0 + 1) | 0;
                            r1 = (r1 + 1) | 0;
                        } else {
                            break repeat22;
                        }
                    }
                }
                r0 = r2 << numDefine24;
                r1 = r3 << numDefine24;
            }
        } while (false);
        r0 = r0 >> numDefine24;
        r1 = r1 >> numDefine24;
        r0 = (r0 - r1) | 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void cmplocales(int sp){
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        r0 = heapClassInst.heap32[r0];
        r1 = heapClassInst.heap32[r1];
        r1 = r1 >> numDefine2;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine38];
        r0 = heapClassInst.heap32[r0 + numDefine38];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        strcmp(i7);
        
    }

    public static void zn21btCollisionDispatcher19defaultNearCallbackER16btBroadphasePairRSRK16btDispatcherInfo(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        double f0 = 0.0;
        double f1 = 0.0;
        int label = 0;
        i7 = sp + numDefineNeg184;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r1 = r1 >> numDefine2;
        r2 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r2];
        r4 = heapClassInst.heap32[r1];
        r5 = heapClassInst.heap32[r1 + 1];
        r3 = r3 >> numDefine2;
        r4 = r4 >> numDefine2;
        r5 = r5 >> numDefine2;
        r4 = heapClassInst.heap32[r4];
        r5 = heapClassInst.heap32[r5];
        r3 = heapClassInst.heap32[r3 + numDefine6];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r3 = commonVariable.rg0;
        repeat1: do {
            if (!(r3 == 0)) {
                r3 = heapClassInst.heap32[fp + numDefine2];
                r6 = heapClassInst.heap32[r1 + numDefine2];
                if (r6 == 0) {
                    r6 = heapClassInst.heap32[r2];
                    r6 = r6 >> numDefine2;
                    r6 = heapClassInst.heap32[r6 + numDefine2];
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r5;
                    heapClassInst.heap32[g0 + numDefine3] = 0;
                    functionTable.get(r6 >> numDefine2).accept(i7);
                    r6 = commonVariable.rg0;
                    heapClassInst.heap32[r1 + numDefine2] = r6;
                    if (r6 == 0) {
                        break repeat1;
                    }
                }
                r0 = ztv16btManifoldResult;
                r1 = sp + numDefineNeg160;
                r0 = (r0 + numDefine8) | 0;
                r2 = r1 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg40] = r0;
                heapClassInst.heap32[r2 + 1] = 0;
                heapClassInst.heap32[r2 + numDefine34] = r4;
                r0 = r4 >> numDefine2;
                heapClassInst.heap32[r2 + numDefine35] = r5;
                heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + 1];
                heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
                heapClassInst.heap32[r2 + numDefine4] = heapClassInst.heap32[r0 + numDefine4];
                heapClassInst.heap32[r2 + numDefine5] = heapClassInst.heap32[r0 + numDefine5];
                heapClassInst.heap32[r2 + numDefine6] = heapClassInst.heap32[r0 + numDefine6];
                heapClassInst.heap32[r2 + numDefine7] = heapClassInst.heap32[r0 + numDefine7];
                heapClassInst.heap32[r2 + numDefine8] = heapClassInst.heap32[r0 + numDefine8];
                heapClassInst.heap32[r2 + numDefine9] = heapClassInst.heap32[r0 + numDefine9];
                heapClassInst.heap32[r2 + numDefine10] = heapClassInst.heap32[r0 + numDefine9];
                heapClassInst.heap32[r2 + numDefine11] = heapClassInst.heap32[r0 + numDefine10];
                heapClassInst.heap32[r2 + numDefine12] = heapClassInst.heap32[r0 + numDefine11];
                heapClassInst.heap32[r2 + numDefine13] = heapClassInst.heap32[r0 + numDefine12];
                heapClassInst.heap32[r2 + numDefine14] = heapClassInst.heap32[r0 + numDefine13];
                heapClassInst.heap32[r2 + numDefine15] = heapClassInst.heap32[r0 + numDefine14];
                heapClassInst.heap32[r2 + numDefine16] = heapClassInst.heap32[r0 + numDefine15];
                r7 = r5 >> numDefine2;
                heapClassInst.heap32[r2 + numDefine17] = heapClassInst.heap32[r0 + numDefine16];
                heapClassInst.heap32[r2 + numDefine18] = heapClassInst.heap32[r7 + 1];
                heapClassInst.heap32[r2 + numDefine19] = heapClassInst.heap32[r7 + numDefine2];
                heapClassInst.heap32[r2 + numDefine20] = heapClassInst.heap32[r7 + numDefine3];
                heapClassInst.heap32[r2 + numDefine21] = heapClassInst.heap32[r7 + numDefine4];
                heapClassInst.heap32[r2 + numDefine22] = heapClassInst.heap32[r7 + numDefine5];
                heapClassInst.heap32[r2 + numDefine23] = heapClassInst.heap32[r7 + numDefine6];
                heapClassInst.heap32[r2 + numDefine24] = heapClassInst.heap32[r7 + numDefine7];
                heapClassInst.heap32[r2 + numDefine25] = heapClassInst.heap32[r7 + numDefine8];
                heapClassInst.heap32[r2 + numDefine26] = heapClassInst.heap32[r7 + numDefine9];
                heapClassInst.heap32[r2 + numDefine27] = heapClassInst.heap32[r7 + numDefine10];
                heapClassInst.heap32[r2 + numDefine28] = heapClassInst.heap32[r7 + numDefine11];
                heapClassInst.heap32[r2 + numDefine29] = heapClassInst.heap32[r7 + numDefine12];
                heapClassInst.heap32[r2 + numDefine30] = heapClassInst.heap32[r7 + numDefine13];
                heapClassInst.heap32[r2 + numDefine31] = heapClassInst.heap32[r7 + numDefine14];
                heapClassInst.heap32[r2 + numDefine32] = heapClassInst.heap32[r7 + numDefine15];
                r0 = r6 >> numDefine2;
                heapClassInst.heap32[r2 + numDefine33] = heapClassInst.heap32[r7 + numDefine16];
                r0 = heapClassInst.heap32[r0];
                r2 = r3 >> numDefine2;
                r7 = heapClassInst.heap32[r2 + numDefine2];
                if (r7 != 1) {
                    r0 = r0 >> numDefine2;
                    r0 = heapClassInst.heap32[r0 + numDefine3];
                    heapClassInst.heap32[g0] = r6;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r5;
                    heapClassInst.heap32[g0 + numDefine3] = r3;
                    heapClassInst.heap32[g0 + numDefine4] = r1;
                    functionTable.get(r0 >> numDefine2).accept(i7);
                    f0 = commonVariable.fg0;
                    f1 = heapClassInst.heapFloat[r2 + numDefine3];
                    if (!(f1 <= f0)) {
                        heapClassInst.heapFloat[r2 + numDefine3] = (float)f0;
                    }
                } else {
                    r0 = r0 >> numDefine2;
                    r0 = heapClassInst.heap32[r0 + numDefine2];
                    heapClassInst.heap32[g0] = r6;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r5;
                    heapClassInst.heap32[g0 + numDefine3] = r3;
                    heapClassInst.heap32[g0 + numDefine4] = r1;
                    functionTable.get(r0 >> numDefine2).accept(i7);
                    
                }
            }
        } while (false);
        
    }

    public static void imandreelRestoreGlcontext(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void iMandreelTextureAsyncGetPackOffset(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int label = 0;
        i7 = sp + numDefineNeg1032;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[fp + numDefine3];
        r4 = sp + numDefineNeg1024;
        r5 = 0;
        repeat1: while (true) {
            r6 = heapClassInst.heapU8[r0];
            if (r6 == 0) {
                break repeat1;
            } else {
                r7 = r6 << numDefine24;
                r7 = r7 >> numDefine24;
                r7 = (r7 + numDefineNeg65) | 0;
                r8 = numDefine26;
                r9 = (r6 + numDefine32) | 0;
                r6 = uint(r7) < uint(r8) ? r9 : r6;
                r7 = r6 & numDefine255;
                r8 = numDefine47;
                r6 = r7 == numDefine92 ? r8 : r6;
                r0 = (r0 + 1) | 0;
                r7 = r6 & numDefine255;
                if (!(r7 != numDefine47)) {
                    r7 = r5 & numDefine255;
                    r5 = r6;
                    if (r7 == numDefine47) {
                        continue repeat1;
                    }
                }
                r5 = (r4 + 1) | 0;
                heapClassInst.heap8[r4] = (byte)r6;
                r4 = r5;
                r5 = r6;
                continue repeat1;
            }
        }
        r0 = zl24gPFirstTextureAsyncInfo;
        r5 = 0;
        heapClassInst.heap8[r4] = (byte)r5;
        repeat8: while (true) {
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0];
            if (r0 != 0) {
                r4 = sp + numDefineNeg1024;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r4;
                strcmp(i7);
                r4 = commonVariable.rg0;
                if (!(r4 != 0)) {
                    r4 = r0 >> numDefine2;
                    r5 = heapClassInst.heap32[r4 + numDefine64];
                    if (!(r5 == -1)) {
                        label = numDefine8;
                        break repeat8;
                    }
                }
                r0 = (r0 + numDefine280) | 0;
                continue repeat8;
            } else {
                label = numDefine11;
                break repeat8;
            }
        }
        switch (label) {
            case numDefine11:
                r0 = 0;
                commonVariable.rg0 = r0;
                
            case numDefine8:
                r0 = r1 >> numDefine2;
                r1 = heapClassInst.heap32[r4 + numDefine68];
                heapClassInst.heap32[r0] = r1;
                r0 = r2 >> numDefine2;
                r1 = heapClassInst.heap32[r4 + numDefine69];
                heapClassInst.heap32[r0] = r1;
                r0 = heapClassInst.heap32[r4 + numDefine64];
                r1 = zl17gApPackFileNames;
                r0 = r0 << numDefine2;
                r0 = (r1 + r0) | 0;
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0];
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r0;
                strcpy(i7);
                r0 = 1;
                commonVariable.rg0 = r0;
                
            default:
                break;
        }
        
    }

    public static void iMandreelTextureAsyncIsCompressed(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int label = 0;
        i7 = sp + numDefineNeg1032;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = sp + numDefineNeg1024;
        r4 = 0;
        repeat1: while (true) {
            r5 = heapClassInst.heapU8[r0];
            if (r5 == 0) {
                break repeat1;
            } else {
                r6 = r5 << numDefine24;
                r6 = r6 >> numDefine24;
                r6 = (r6 + numDefineNeg65) | 0;
                r7 = numDefine26;
                r8 = (r5 + numDefine32) | 0;
                r5 = uint(r6) < uint(r7) ? r8 : r5;
                r6 = r5 & numDefine255;
                r7 = numDefine47;
                r5 = r6 == numDefine92 ? r7 : r5;
                r0 = (r0 + 1) | 0;
                r6 = r5 & numDefine255;
                if (!(r6 != numDefine47)) {
                    r6 = r4 & numDefine255;
                    r4 = r5;
                    if (r6 == numDefine47) {
                        continue repeat1;
                    }
                }
                r4 = (r3 + 1) | 0;
                heapClassInst.heap8[r3] = (byte)r5;
                r3 = r4;
                r4 = r5;
                continue repeat1;
            }
        }
        r0 = zl24gPFirstTextureAsyncInfo;
        r4 = 0;
        heapClassInst.heap8[r3] = (byte)r4;
        repeat8: while (true) {
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0];
            if (r0 != 0) {
                r3 = sp + numDefineNeg1024;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r3;
                strcmp(i7);
                r3 = commonVariable.rg0;
                if (r3 != 0) {
                    r0 = (r0 + numDefine280) | 0;
                    continue repeat8;
                } else {
                    label = numDefine7;
                    break repeat8;
                }
            } else {
                label = numDefine10;
                break repeat8;
            }
        }
        switch (label) {
            case numDefine10:
                r0 = -1;
                commonVariable.rg0 = r0;
                
            case numDefine7:
                r0 = r0 >> numDefine2;
                r1 = r1 >> numDefine2;
                r3 = heapClassInst.heap32[r0 + numDefine65];
                heapClassInst.heap32[r1] = r3;
                r1 = r2 >> numDefine2;
                r2 = heapClassInst.heap32[r0 + numDefine66];
                heapClassInst.heap32[r1] = r2;
                r0 = heapClassInst.heap32[r0 + numDefine67];
                commonVariable.rg0 = r0;
                
            default:
                break;
        }
        
    }

    public static void imandreelViewportResize(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void mandreelFlashTcpOnError(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void z31MandreelDefaultDebugMsgCallbackiPKc(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[g0] = r0;
        sandboxOutputDebugString(i7);
        
    }

    public static void fwrite(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r1 = heapClassInst.heap32[fp];
        r2 = heapClassInst.heap32[fp + 1];
        if (!(uint(r0) > uint(numDefine9))) {
            r0 = zl13sFileStdout;
        }
        r3 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = 1;
        heapClassInst.heap32[g0 + numDefine3] = r2;
        functionTable.get(r3 >> numDefine2).accept(i7);
        
    }

    public static void mandreelInternalSetResolution(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = zl25sMandreelInternalWidth;
        r1 = zl26sMandreelInternalHeight;
        r0 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp];
        r1 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r0] = r2;
        heapClassInst.heap32[r1] = r3;
        
    }

    public static void resize(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        
    }

    public static void myMandreelCallConstructors(int ptr, int size,int stackPos) {
        myHeapNewPos = commonVariable.heapNewPos;
        heapClassInst.myHeap = ByteBuffer.allocateDirect(mandreelTotalMemory);
        heapClassInst.myHeap8 = heapClassInst.myHeap;
        heapClassInst.myHeap32 = heapClassInst.myHeap.asIntBuffer();

        for (int i = 0; i < mandreelTotalMemory / numDefine4; i++) {
            heapClassInst.myHeap32.put(i, heapClassInst.heap32[i]);
        }
        mandreelCallConstructors(ptr, size, stackPos);
    }
}


